Update app.py

app.py

@@ -2,51 +2,104 @@ import gradio as gr
 import os
 import json
 import asyncio
-from typing import Optional
-from mcp import ClientSession, StdioServerParameters
-from mcp.client.stdio import stdio_client
 import httpx
+from typing import Optional, Dict, Any
 
-class MCPTrainClient:
-    """MCP Client für Zugverbindungsabfragen"""
+class MCPHTTPClient:
+    """MCP Client für Streamable HTTP Transport"""
     
     def __init__(self, server_url: str):
-        self.server_url = server_url
-        self.session: Optional[ClientSession] = None
+        self.server_url = server_url.rstrip('/')
         self.tools = []
+        self.client = httpx.AsyncClient(timeout=30.0)
         
-    async def connect(self):
-        """Stelle Verbindung zum MCP-Server her"""
+    async def initialize(self):
+        """Initialisiere den Client und hole verfügbare Tools"""
         try:
-            # Für Streamable HTTP Transport verwenden wir httpx
-            # Die Session wird über die MCP-URL initialisiert
-            self.session = ClientSession()
+            # MCP über HTTP: Sende initialize request
+            response = await self.client.post(
+                f"{self.server_url}/initialize",
+                json={
+                    "jsonrpc": "2.0",
+                    "id": 1,
+                    "method": "initialize",
+                    "params": {
+                        "protocolVersion": "2024-11-05",
+                        "capabilities": {},
+                        "clientInfo": {
+                            "name": "gradio-mcp-client",
+                            "version": "1.0.0"
+                        }
+                    }
+                }
+            )
             
-            # Tools vom Server abrufen
-            await self.list_tools()
-            return True
+            if response.status_code == 200:
+                print("MCP-Server initialisiert")
+                await self.list_tools()
+                return True
+            else:
+                print(f"Initialisierung fehlgeschlagen: {response.status_code}")
+                return False
+                
         except Exception as e:
-            print(f"Verbindungsfehler: {e}")
+            print(f"Verbindungsfehler bei Initialisierung: {e}")
             return False
     
     async def list_tools(self):
         """Rufe verfügbare Tools vom MCP-Server ab"""
         try:
-            if self.session:
-                response = await self.session.list_tools()
-                self.tools = response.tools
-                print(f"Verfügbare Tools: {[tool.name for tool in self.tools]}")
+            response = await self.client.post(
+                f"{self.server_url}/list_tools",
+                json={
+                    "jsonrpc": "2.0",
+                    "id": 2,
+                    "method": "tools/list",
+                    "params": {}
+                }
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                if "result" in data and "tools" in data["result"]:
+                    self.tools = data["result"]["tools"]
+                    print(f"Verfügbare Tools: {[tool['name'] for tool in self.tools]}")
+                else:
+                    print("Keine Tools gefunden")
+            else:
+                print(f"Fehler beim Abrufen der Tools: {response.status_code}")
+                
         except Exception as e:
             print(f"Fehler beim Abrufen der Tools: {e}")
     
-    async def call_tool(self, tool_name: str, arguments: dict):
-        """Rufe ein spezifisches Tool auf dem MCP-Server auf"""
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]):
+        """Rufe ein Tool auf dem MCP-Server auf"""
         try:
-            if not self.session:
-                await self.connect()
+            response = await self.client.post(
+                f"{self.server_url}/call_tool",
+                json={
+                    "jsonrpc": "2.0",
+                    "id": 3,
+                    "method": "tools/call",
+                    "params": {
+                        "name": tool_name,
+                        "arguments": arguments
+                    }
+                }
+            )
             
-            result = await self.session.call_tool(tool_name, arguments)
-            return result
+            if response.status_code == 200:
+                data = response.json()
+                if "result" in data:
+                    return data["result"]
+                else:
+                    print(f"Unerwartete Antwort: {data}")
+                    return None
+            else:
+                print(f"Tool-Aufruf fehlgeschlagen: {response.status_code}")
+                print(f"Response: {response.text}")
+                return None
+                
         except Exception as e:
             print(f"Fehler beim Tool-Aufruf: {e}")
             return None
@@ -63,42 +116,58 @@ class MCPTrainClient:
                 }
             )
             
-            if result and hasattr(result, 'content'):
-                return self._parse_result(result.content)
+            if result:
+                return self._parse_result(result)
             return None
+            
         except Exception as e:
             print(f"Fehler bei der Verbindungssuche: {e}")
             return None
     
-    def _parse_result(self, content):
+    def _parse_result(self, result):
         """Parse die Antwort vom MCP-Server"""
         try:
-            if isinstance(content, list) and len(content) > 0:
-                # Extrahiere den Text aus der Antwort
-                if hasattr(content[0], 'text'):
-                    return content[0].text
-                elif isinstance(content[0], dict) and 'text' in content[0]:
-                    return content[0]['text']
-            return str(content)
+            # MCP-Server gibt Ergebnisse im content-Array zurück
+            if isinstance(result, dict) and "content" in result:
+                content = result["content"]
+                if isinstance(content, list) and len(content) > 0:
+                    if isinstance(content[0], dict) and "text" in content[0]:
+                        return content[0]["text"]
+                    elif hasattr(content[0], 'text'):
+                        return content[0].text
+                return str(content)
+            
+            return str(result)
+            
         except Exception as e:
             print(f"Fehler beim Parsen: {e}")
-            return None
+            return str(result)
+    
+    async def close(self):
+        """Schließe die HTTP-Verbindung"""
+        await self.client.aclose()
 
 
 # Globaler MCP-Client
-mcp_client = None
-MCP_SERVER_URL = "https://mgokg-db-timetable-api.hf.space/gradio_api/mcp/"
+mcp_client: Optional[MCPHTTPClient] = None
+MCP_SERVER_URL = "https://mgokg-db-timetable-api.hf.space/gradio_api/mcp"
 
 
 async def initialize_mcp_client():
     """Initialisiere den MCP-Client"""
     global mcp_client
     try:
-        mcp_client = MCPTrainClient(MCP_SERVER_URL)
-        await mcp_client.connect()
-        return "MCP-Client erfolgreich initialisiert"
+        mcp_client = MCPHTTPClient(MCP_SERVER_URL)
+        success = await mcp_client.initialize()
+        
+        if success:
+            return "✅ MCP-Client erfolgreich initialisiert"
+        else:
+            return "⚠️ MCP-Client initialisiert, aber keine Tools verfügbar"
+            
     except Exception as e:
-        return f"Fehler bei der Initialisierung: {e}"
+        print(f"Fehler bei der Initialisierung: {e}")
+        return f"❌ Fehler bei der Initialisierung: {e}"
 
 
 async def search_train_connections_async(user_input: str):
@@ -107,42 +176,83 @@ async def search_train_connections_async(user_input: str):
     
     # Initialisiere Client falls noch nicht geschehen
     if mcp_client is None:
-        await initialize_mcp_client()
+        init_msg = await initialize_mcp_client()
+        if "❌" in init_msg:
+            return f"{init_msg}\n\nBitte versuchen Sie es später erneut."
     
     try:
         # Extrahiere Start und Ziel aus der Benutzereingabe
-        # Einfache Parsing-Logik (kann erweitert werden)
-        parts = user_input.lower().replace("von", "").replace("nach", "").strip().split()
+        user_input_lower = user_input.lower().strip()
         
-        if len(parts) < 2:
-            return "Bitte geben Sie Start- und Zielort an (z.B. 'Frankfurt nach Berlin')"
+        # Verschiedene Parsing-Strategien
+        origin, destination = None, None
         
-        # Versuche, Start und Ziel zu identifizieren
-        if "nach" in user_input.lower():
-            split_parts = user_input.lower().split("nach")
-            origin = split_parts[0].replace("von", "").strip()
-            destination = split_parts[1].strip()
+        if " nach " in user_input_lower:
+            parts = user_input_lower.split(" nach ")
+            origin = parts[0].replace("von", "").strip()
+            destination = parts[1].strip()
+        elif " - " in user_input_lower:
+            parts = user_input_lower.split(" - ")
+            origin = parts[0].strip()
+            destination = parts[1].strip()
         else:
-            origin = parts[0].capitalize()
-            destination = parts[-1].capitalize()
+            # Versuche einfache Tokenisierung
+            words = user_input_lower.replace("von", "").replace(",", "").split()
+            if len(words) >= 2:
+                origin = words[0]
+                destination = words[-1]
+        
+        if not origin or not destination:
+            return """❓ Bitte geben Sie Start- und Zielort an.
+
+**Beispiele:**
+- Frankfurt nach Berlin
+- Von München nach Hamburg  
+- Köln - Stuttgart
+- Hamburg Berlin"""
+        
+        # Kapitalisiere die Namen
+        origin = origin.capitalize()
+        destination = destination.capitalize()
+        
+        # Zeige Suche an
+        print(f"Suche Verbindungen: {origin} → {destination}")
         
         # Rufe MCP-Server auf
         result = await mcp_client.search_connections(origin, destination)
         
         if result:
             # Formatiere Ergebnis als Markdown
-            response = f"## Zugverbindungen von {origin} nach {destination}\n\n"
+            response = f"## 🚂 Zugverbindungen von {origin} nach {destination}\n\n"
             response += result
             return response
         else:
-            return "Keine Verbindungen gefunden oder Fehler bei der Abfrage."
+            return f"""⚠️ Keine Verbindungen gefunden oder Fehler bei der Abfrage.
+
+**Gesuchte Route:** {origin} → {destination}
+
+Bitte prüfen Sie:
+- Sind die Ortsnamen korrekt geschrieben?
+- Existieren die Bahnhöfe?
+- Versuchen Sie es mit vollständigen Stadtnamen"""
             
     except Exception as e:
-        return f"Fehler bei der Suche: {str(e)}\n\nBitte versuchen Sie es erneut oder prüfen Sie Ihre Eingabe."
+        error_msg = str(e)
+        print(f"Fehler bei der Suche: {error_msg}")
+        return f"""❌ Fehler bei der Suche: {error_msg}
+
+Bitte versuchen Sie es erneut oder verwenden Sie ein anderes Format.
+
+**Beispiele:**
+- Frankfurt nach Berlin
+- Von München nach Hamburg"""
 
 
 def search_train_connections(user_input: str):
     """Synchrone Wrapper-Funktion für Gradio"""
+    if not user_input or not user_input.strip():
+        return "Bitte geben Sie eine Anfrage ein.", ""
+    
     try:
         # Erstelle neuen Event Loop für die asynchrone Funktion
         loop = asyncio.new_event_loop()
@@ -151,12 +261,15 @@ def search_train_connections(user_input: str):
         loop.close()
         return result, ""
     except Exception as e:
-        return f"Fehler: {str(e)}", ""
+        return f"❌ Fehler: {str(e)}", ""
 
 
 if __name__ == '__main__':
     # Initialisiere MCP-Client beim Start
-    print("Initialisiere MCP-Client...")
+    print("=" * 60)
+    print("🚂 Deutsche Bahn MCP-Client wird gestartet...")
+    print("=" * 60)
+    
     try:
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
@@ -164,28 +277,43 @@ if __name__ == '__main__':
         print(init_result)
         loop.close()
     except Exception as e:
-        print(f"Warnung bei Initialisierung: {e}")
+        print(f"⚠️ Warnung bei Initialisierung: {e}")
         print("Client wird bei erster Anfrage initialisiert.")
     
+    print("=" * 60)
+    
     # Gradio Interface
-    with gr.Blocks() as demo:
-        title = gr.Markdown("# 🚂 Deutsche Bahn Zugverbindungen (MCP-Client)")
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        title = gr.Markdown("# 🚂 Deutsche Bahn Zugverbindungen")
+        gr.Markdown("### MCP-Client für DB Timetable API")
+        
         description = gr.Markdown("""
-        Geben Sie Start- und Zielort ein, um Zugverbindungen zu finden.
+        Geben Sie Start- und Zielort ein, um aktuelle Zugverbindungen zu finden.
         
-        **Beispiele:**
-        - Frankfurt nach Berlin
-        - Von München nach Hamburg
-        - Köln Stuttgart
+        **Beispiele für Eingaben:**
+        - `Frankfurt nach Berlin`
+        - `Von München nach Hamburg`
+        - `Köln - Stuttgart`
+        - `Hamburg Berlin`
         """)
         
-        output_textbox = gr.Markdown()
-        input_textbox = gr.Textbox(
-            lines=2, 
-            label="Ihre Anfrage", 
-            placeholder="z.B. 'Frankfurt nach Berlin' oder 'Von München nach Hamburg'"
-        )
-        submit_button = gr.Button("🔍 Verbindungen suchen")
+        with gr.Row():
+            with gr.Column(scale=4):
+                input_textbox = gr.Textbox(
+                    lines=2, 
+                    label="Ihre Anfrage", 
+                    placeholder="z.B. 'Frankfurt nach Berlin' oder 'Von München nach Hamburg'",
+                    autofocus=True
+                )
+            with gr.Column(scale=1):
+                submit_button = gr.Button("🔍 Suchen", variant="primary", size="lg")
+        
+        output_textbox = gr.Markdown(label="Ergebnisse")
+        
+        gr.Markdown("""
+        ---
+        💡 **Hinweis:** Dieser Client nutzt die Deutsche Bahn Timetable API über einen MCP-Server.
+        """)
         
         # Event Handler
         submit_button.click(