Update app.py

app.py

@@ -5,164 +5,428 @@ import json
 import asyncio
 import aiohttp
 from typing import Dict, Any, List, Tuple
+from datetime import datetime
+import os
 
 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"""
         if arguments is None:
             arguments = {}
-
+        
         await self.initialize_session()
-
+        
         mcp_request = {
             "jsonrpc": "2.0",
             "id": 1,
             "method": "tools/call",
-            "params": {"name": tool_name, "arguments": arguments}
+            "params": {
+                "name": tool_name,
+                "arguments": arguments
+            }
         }
-
+        
         try:
-            async with self.session.post(f"{self.server_url}/mcp", json=mcp_request) as response:
-                return await response.json()
+            async with self.session.post(
+                f"{self.server_url}/mcp",
+                json=mcp_request,
+                headers={
+                    "Content-Type": "application/json",
+                    "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()}"
+                    }
         except Exception as e:
-            return {"success": False, "error": str(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()
-        mcp_request = {"jsonrpc": "2.0", "id": 1, "method": "tools/list"}
+        
+        mcp_request = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "tools/list"
+        }
+        
         try:
-            async with self.session.post(f"{self.server_url}/mcp", json=mcp_request) as response:
-                result = await response.json()
-                return result.get("result", {}).get("tools", [])
-        except:
+            async with self.session.post(
+                f"{self.server_url}/mcp",
+                json=mcp_request,
+                headers={
+                    "Content-Type": "application/json",
+                    "ngrok-skip-browser-warning": "true"
+                },
+                timeout=30
+            ) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    return result.get("result", {}).get("tools", [])
+                return []
+        except Exception as e:
+            print(f"Error listing tools: {str(e)}")  # For debugging
             return []
 
 class AIAssistant:
+    """AI Assistant with MCP integration"""
+    
     def __init__(self, openai_api_key: str, mcp_client: MCPClient):
-        self.openai_client = openai.OpenAI(api_key=openai_api_key)
+        try:
+            self.openai_client = openai.OpenAI(
+                api_key=openai_api_key,
+                timeout=30.0
+            )
+        except Exception as e:
+            # Fallback for older OpenAI versions
+            openai.api_key = openai_api_key
+            self.openai_client = openai
         self.mcp_client = mcp_client
         self.available_tools = []
-
+    
     async def initialize(self):
+        """Initialize the assistant by fetching available tools"""
         self.available_tools = await self.mcp_client.list_tools()
-
+    
     def get_system_prompt(self) -> str:
+        """Generate system prompt with available tools"""
         tools_description = "\n".join([
             f"- {tool['name']}: {tool['description']}"
             for tool in self.available_tools
         ])
-        return f"""You are an AI assistant with access to tools:
+        
+        return f"""You are an AI assistant with access to SAP business systems and news data through specialized tools. 
+
+Available tools:
 {tools_description}
 
-Use these tools explicitly if user queries require external data. 
+When a user asks for information that can be retrieved using these tools, you should:
+1. Identify which tool(s) would be helpful
+2. Call the appropriate tool(s) with the right parameters
+3. Interpret and present the results in a user-friendly way
 
-Respond with 'CALL_TOOL: tool_name(parameter=value)' to invoke tools.
-"""
+For SAP-related queries (purchase orders, requisitions), use the SAP tools.
+For news-related queries, use the news tools.
 
+You can call tools by responding with: CALL_TOOL: tool_name(parameter1=value1, parameter2=value2)
+"""
+    
     def extract_tool_calls(self, response: str) -> List[Dict[str, Any]]:
+        """Extract tool calls from AI response"""
         tool_calls = []
         lines = response.split('\n')
+        
         for line in lines:
-            if line.startswith('CALL_TOOL:'):
-                tool_part = line[len('CALL_TOOL:'):].strip()
-                tool_name, args = tool_part.split('(', 1)
-                args = args.rstrip(')')
-                arg_dict = {}
-                for arg in args.split(','):
-                    key, value = arg.split('=')
-                    arg_dict[key.strip()] = value.strip().strip('"\'')
-                tool_calls.append({'name': tool_name.strip(), 'arguments': arg_dict})
+            if line.strip().startswith('CALL_TOOL:'):
+                try:
+                    tool_part = line.strip()[10:].strip()
+                    
+                    if '(' in tool_part and ')' in tool_part:
+                        tool_name = tool_part.split('(')[0].strip()
+                        params_str = tool_part.split('(')[1].split(')')[0]
+                        
+                        params = {}
+                        if params_str.strip():
+                            for param in params_str.split(','):
+                                if '=' in param:
+                                    key, value = param.split('=', 1)
+                                    key = key.strip()
+                                    value = value.strip().strip('"\'')
+                                    try:
+                                        if value.isdigit():
+                                            value = int(value)
+                                        elif value.lower() in ['true', 'false']:
+                                            value = value.lower() == 'true'
+                                    except:
+                                        pass
+                                    params[key] = value
+                        
+                        tool_calls.append({
+                            'name': tool_name,
+                            'arguments': params
+                        })
+                except Exception as e:
+                    continue
+        
         return tool_calls
-
+    
     async def process_message(self, user_message: str) -> Tuple[str, str]:
-        messages = [
-            {"role": "system", "content": self.get_system_prompt()},
-            {"role": "user", "content": user_message}
-        ]
-        response = self.openai_client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=messages,
-            temperature=0
-        )
-        ai_response = response.choices[0].message.content
-        tool_calls = self.extract_tool_calls(ai_response)
-
+        """Process user message and handle tool calls"""
         tool_info = ""
-        if tool_calls:
-            tool_results = []
-            for call in tool_calls:
-                result = await self.mcp_client.call_tool(call['name'], call['arguments'])
-                tool_results.append(result)
-                tool_info += f"Called {call['name']}: {result}\n"
-
-            # Let AI interpret the tool results
-            final_messages = messages + [
-                {"role": "assistant", "content": ai_response},
-                {"role": "user", "content": f"Tool results:\n{json.dumps(tool_results)}"}
+        
+        try:
+            messages = [
+                {"role": "system", "content": self.get_system_prompt()},
+                {"role": "user", "content": user_message}
             ]
+            
+            # Check if we have a proper OpenAI client
+            if hasattr(self.openai_client, 'chat'):
+                response = self.openai_client.chat.completions.create(
+                    model="gpt-3.5-turbo",
+                    messages=messages,
+                    temperature=0.7,
+                    max_tokens=1000
+                )
+                ai_response = response.choices[0].message.content
+            else:
+                # Fallback for older API
+                response = self.openai_client.ChatCompletion.create(
+                    model="gpt-3.5-turbo",
+                    messages=messages,
+                    temperature=0.7,
+                    max_tokens=1000
+                )
+                ai_response = response.choices[0].message.content
+            tool_calls = self.extract_tool_calls(ai_response)
+            
+            if tool_calls:
+                tool_results = []
+                
+                for tool_call in tool_calls:
+                    tool_info += f"🔧 Calling: {tool_call['name']}\n"
+                    
+                    result = await self.mcp_client.call_tool(
+                        tool_call['name'], 
+                        tool_call['arguments']
+                    )
+                    
+                    tool_results.append({
+                        'tool': tool_call['name'],
+                        'result': result
+                    })
+                    
+                    if result.get('success'):
+                        tool_info += f"✅ {tool_call['name']} completed\n"
+                    else:
+                        tool_info += f"❌ {tool_call['name']} failed: {result.get('error', 'Unknown error')}\n"
+                
+                tool_results_text = "\n\n".join([
+                    f"Tool: {tr['tool']}\nResult: {json.dumps(tr['result'], indent=2)}"
+                    for tr in tool_results
+                ])
+                
+                final_messages = messages + [
+                    {"role": "assistant", "content": ai_response},
+                    {"role": "user", "content": f"Here are the tool results:\n\n{tool_results_text}\n\nPlease interpret these results and provide a helpful response to the user."}
+                ]
+                
+                # Get final response with tool results
+                if hasattr(self.openai_client, 'chat'):
+                    final_response = self.openai_client.chat.completions.create(
+                        model="gpt-3.5-turbo",
+                        messages=final_messages,
+                        temperature=0.7,
+                        max_tokens=1000
+                    )
+                    return final_response.choices[0].message.content, tool_info
+                else:
+                    final_response = self.openai_client.ChatCompletion.create(
+                        model="gpt-3.5-turbo",
+                        messages=final_messages,
+                        temperature=0.7,
+                        max_tokens=1000
+                    )
+                    return final_response.choices[0].message.content, tool_info
+            else:
+                return ai_response, ""
+                
+        except Exception as e:
+            return f"❌ Error processing your request: {str(e)}", ""
 
-            final_response = self.openai_client.chat.completions.create(
-                model="gpt-3.5-turbo",
-                messages=final_messages,
-                temperature=0
-            )
-            return final_response.choices[0].message.content, tool_info
-
-        return ai_response, ""
-
-
-# Globals
+# Global variables
 assistant = None
+mcp_client = None
 
-async def initialize_assistant(openai_key, mcp_url):
-    global assistant
-    if not openai_key or not mcp_url:
-        return "❌ Provide valid OpenAI API key and MCP URL"
+def test_connection(mcp_url):
+    """Test MCP server connection"""
+    if not mcp_url or mcp_url == "https://your-ngrok-url.ngrok.io":
+        return "❌ Please enter a valid MCP server URL"
+    
+    try:
+        # Test health endpoint
+        response = requests.get(f"{mcp_url.rstrip('/')}/health", timeout=10)
+        if response.status_code == 200:
+            data = response.json()
+            
+            # Test MCP tools list
+            mcp_request = {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "tools/list"
+            }
+            
+            mcp_response = requests.post(
+                f"{mcp_url.rstrip('/')}/mcp",
+                json=mcp_request,
+                headers={
+                    "Content-Type": "application/json",
+                    "ngrok-skip-browser-warning": "true"
+                },
+                timeout=10
+            )
+            
+            if mcp_response.status_code == 200:
+                mcp_data = mcp_response.json()
+                tools = mcp_data.get("result", {}).get("tools", [])
+                tool_names = [tool.get("name", "Unknown") for tool in tools]
+                
+                return f"✅ Connected successfully!\nHealth Status: {data.get('status', 'Unknown')}\nMCP Tools: {len(tools)}\nAvailable: {', '.join(tool_names)}"
+            else:
+                return f"✅ Health OK, but MCP endpoint failed: HTTP {mcp_response.status_code}"
+        else:
+            return f"❌ Connection failed: HTTP {response.status_code}"
+    except Exception as e:
+        return f"❌ Connection error: {str(e)}"
 
-    mcp_client = MCPClient(mcp_url)
-    assistant = AIAssistant(openai_key, mcp_client)
-    await assistant.initialize()
-    return f"✅ Initialized with {len(assistant.available_tools)} tools"
+async def initialize_assistant(openai_key, mcp_url):
+    """Initialize the AI assistant"""
+    global assistant, mcp_client
+    
+    if not openai_key:
+        return "❌ Please enter your OpenAI API key"
+    
+    if not mcp_url or mcp_url == "https://your-ngrok-url.ngrok.io":
+        return "❌ Please enter a valid MCP server URL"
+    
+    try:
+        mcp_client = MCPClient(mcp_url)
+        assistant = AIAssistant(openai_key, mcp_client)
+        await 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)}"
 
-async def chat_interface(message, history, openai_key, mcp_url):
+def chat_interface(message, history, openai_key, mcp_url):
+    """Main chat interface"""
     global assistant
+    
     if not assistant:
-        init_result = await initialize_assistant(openai_key, mcp_url)
+        init_result = asyncio.run(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))
+        
+        # Format response with tool info if available
+        if tool_info:
+            full_response = f"**Tool Execution:**\n{tool_info}\n\n**Response:**\n{response}"
+        else:
+            full_response = response
+            
+        history.append([message, full_response])
+        return history, ""
+    except Exception as e:
+        error_response = f"❌ Error: {str(e)}"
+        history.append([message, error_response])
+        return history, ""
 
-    response, tool_info = await assistant.process_message(message)
-    full_response = f"{response}\n\n{tool_info}" if tool_info else response
-    history.append([message, full_response])
-    return history, ""
-
-with gr.Blocks() as demo:
-    gr.Markdown("# 🤖 MCP Assistant")
-    chatbot = gr.Chatbot(height=400)
-    msg = gr.Textbox(placeholder="Ask me anything...")
-    openai_key = gr.Textbox(type="password", label="OpenAI API Key")
-    mcp_url = gr.Textbox(label="MCP Server URL")
-
-    submit_btn = gr.Button("Send")
+# Create Gradio interface
+with gr.Blocks(title="AI Assistant with SAP & News Integration", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🤖 AI Assistant with SAP & News Integration")
+    gr.Markdown("Chat with an AI that can access SAP business data and news through natural language queries.")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(
+                height=500,
+                show_label=False,
+                container=True,
+                bubble_full_width=False
+            )
+            
+            msg = gr.Textbox(
+                placeholder="Ask me about SAP data, news, or anything else...",
+                show_label=False,
+                container=False
+            )
+            
+            with gr.Row():
+                submit_btn = gr.Button("Send", variant="primary")
+                clear_btn = gr.Button("Clear", variant="secondary")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### ⚙️ Configuration")
+            
+            openai_key = gr.Textbox(
+                label="OpenAI API Key",
+                type="password",
+                placeholder="sk-..."
+            )
+            
+            mcp_url = gr.Textbox(
+                label="MCP Server URL",
+                value="https://your-ngrok-url.ngrok.io",
+                placeholder="https://abc123.ngrok.io"
+            )
+            
+            test_btn = gr.Button("Test Connection", variant="secondary")
+            connection_status = gr.Textbox(label="Connection Status", interactive=False)
+            
+            gr.Markdown("### 📋 Example Queries")
+            gr.Markdown("""
+            - "Show me recent purchase orders"
+            - "Get purchase requisitions"
+            - "What's the latest tech news?"
+            - "Get news from BBC"
+            - "Show me business news from the US"
+            """)
+    
+    # Event handlers
+    def respond(message, history, openai_key, mcp_url):
+        return chat_interface(message, history, openai_key, mcp_url)
+    
     submit_btn.click(
-        chat_interface, [msg, chatbot, openai_key, mcp_url], [chatbot, msg]
+        respond,
+        [msg, chatbot, openai_key, mcp_url],
+        [chatbot, msg]
     )
+    
     msg.submit(
-        chat_interface, [msg, chatbot, openai_key, mcp_url], [chatbot, msg]
+        respond,
+        [msg, chatbot, openai_key, mcp_url],
+        [chatbot, msg]
+    )
+    
+    clear_btn.click(lambda: ([], ""), outputs=[chatbot, msg])
+    
+    test_btn.click(
+        test_connection,
+        [mcp_url],
+        [connection_status]
     )
 
-demo.launch()
-
+if __name__ == "__main__":
+    demo.launch()