Update app.py

app.py

@@ -11,8 +11,11 @@ import hashlib
 from pathlib import Path
 import requests
 from io import BytesIO
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import threading
 
-class HFSecretsFileStorageMCP:
+class HFUUIDSSEFileStorageMCP:
     def __init__(self):
         # Lade Secrets aus Space Environment
         self.hf_token = os.environ.get("HF_TOKEN", "")
@@ -20,29 +23,24 @@ class HFSecretsFileStorageMCP:
         self.org_name = os.environ.get("ORG_NAME", "mcp-filestorage")
         self.db_path = "user_management.db"
         
-        # Fallback auf lokale Variablen falls Secrets nicht verfügbar
-        if not self.hf_token:
-            print("⚠️  HF_TOKEN nicht in Secrets gefunden, verwende leeren Token")
-        if not self.dataset_name or self.dataset_name == "mcp-filestorage/default-files":
-            print("⚠️  DATASET_NAME nicht in Secrets gefunden, erstelle lokalen Speicher")
-        
         self.api = HfApi(token=self.hf_token if self.hf_token else None)
         self.init_database()
         self.init_storage()
-    
+        self.user_sessions = {}  # Speichert aktive Benutzer-Sessions
+        
     def init_database(self):
         """Initialisiert SQLite-Datenbank für Benutzerverwaltung"""
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
         
-        # Benutzer-Tabelle
+        # Benutzer-Tabelle mit SSE-Endpunkt
         cursor.execute('''
             CREATE TABLE IF NOT EXISTS users (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 user_uuid TEXT UNIQUE NOT NULL,
+                sse_endpoint TEXT UNIQUE,
                 created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                 last_access DATETIME DEFAULT CURRENT_TIMESTAMP,
-                folder_count INTEGER DEFAULT 0,
                 file_count INTEGER DEFAULT 0,
                 is_active BOOLEAN DEFAULT 1,
                 storage_type TEXT DEFAULT 'hf_dataset'
@@ -76,12 +74,10 @@ class HFSecretsFileStorageMCP:
         """Initialisiert Speicher (Dataset oder lokal)"""
         try:
             if self.dataset_name and self.dataset_name != "mcp-filestorage/default-files":
-                # Versuche Dataset zu laden
                 self.dataset = load_dataset(self.dataset_name, split='train', token=self.hf_token)
                 print(f"✅ Dataset geladen: {self.dataset_name}")
                 self.storage_mode = 'dataset'
             else:
-                # Lokaler Speicher als Fallback
                 self.storage_mode = 'local'
                 self.local_storage_path = Path("user_storage")
                 self.local_storage_path.mkdir(exist_ok=True)
@@ -93,24 +89,38 @@ class HFSecretsFileStorageMCP:
             self.local_storage_path.mkdir(exist_ok=True)
 
     def register_user(self) -> Dict[str, Any]:
-        """Registriert neuen Benutzer mit UUID"""
+        """Registriert neuen Benutzer mit UUID und erstellt SSE-Endpunkt"""
         user_uuid = str(uuid.uuid4())
+        sse_endpoint = f"user-{user_uuid[:8]}"  # Kurze UUID für Endpoint
         
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
         
         try:
-            cursor.execute('INSERT INTO users (user_uuid) VALUES (?)', (user_uuid,))
+            cursor.execute('''
+                INSERT INTO users (user_uuid, sse_endpoint) VALUES (?, ?)
+            ''', (user_uuid, sse_endpoint))
+            
             conn.commit()
             
             # Erstelle Benutzerordner
             self._create_user_folder(user_uuid)
             
+            # Registriere Benutzer-Session
+            self.user_sessions[user_uuid] = {
+                'sse_endpoint': sse_endpoint,
+                'created_at': datetime.now(),
+                'last_access': datetime.now()
+            }
+            
             return {
                 'success': True,
                 'user_uuid': user_uuid,
+                'sse_endpoint': sse_endpoint,
+                'full_sse_url': f"/gradio_api/mcp/user/{user_uuid}/sse",
                 'message': f'Benutzer {user_uuid} registriert'
             }
+            
         except Exception as e:
             return {
                 'success': False,
@@ -118,12 +128,35 @@ class HFSecretsFileStorageMCP:
             }
         finally:
             conn.close()
-    
+
+    def get_user_by_uuid(self, user_uuid: str) -> Optional[Dict[str, Any]]:
+        """Holt Benutzer-Informationen anhand der UUID"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute('''
+                SELECT user_uuid, sse_endpoint, created_at, file_count
+                FROM users WHERE user_uuid = ? AND is_active = 1
+            ''', (user_uuid,))
+            
+            result = cursor.fetchone()
+            if result:
+                return {
+                    'user_uuid': result[0],
+                    'sse_endpoint': result[1],
+                    'created_at': result[2],
+                    'file_count': result[3]
+                }
+            return None
+            
+        finally:
+            conn.close()
+
     def _create_user_folder(self, user_uuid: str):
         """Erstellt Benutzerordner je nach Speicher-Modus"""
         if self.storage_mode == 'dataset':
             try:
-                # Erstelle Ordner-Struktur im Dataset
                 folder_path = f"users/{user_uuid}"
                 readme_content = f"# User Folder: {user_uuid}\nCreated: {datetime.now().isoformat()}\n"
                 
@@ -144,6 +177,11 @@ class HFSecretsFileStorageMCP:
     def create_file(self, user_uuid: str, file_path: str, content: bytes, 
                    metadata: Optional[Dict] = None) -> Dict[str, Any]:
         """Erstellt neue Datei für Benutzer"""
+        # Verifiziere Benutzer
+        user = self.get_user_by_uuid(user_uuid)
+        if not user:
+            return {'success': False, 'error': 'Ungültige Benutzer-UUID'}
+        
         file_uuid = str(uuid.uuid4())
         file_hash = hashlib.sha256(content).hexdigest()
         
@@ -151,9 +189,9 @@ class HFSecretsFileStorageMCP:
         cursor = conn.cursor()
         
         try:
-            # Speichere Datei je nach Modus
             storage_path = f"users/{user_uuid}/{file_path}"
             
+            # Speichere Datei
             if self.storage_mode == 'dataset':
                 try:
                     self.api.upload_file(
@@ -186,24 +224,29 @@ class HFSecretsFileStorageMCP:
             
             conn.commit()
             
+            # Aktualisiere Session
+            if user_uuid in self.user_sessions:
+                self.user_sessions[user_uuid]['last_access'] = datetime.now()
+            
             return {
                 'success': True,
                 'file_uuid': file_uuid,
                 'file_path': file_path,
-                'storage_path': storage_path,
-                'storage_mode': self.storage_mode
+                'user_uuid': user_uuid
             }
             
         except Exception as e:
-            return {
-                'success': False,
-                'error': str(e)
-            }
+            return {'success': False, 'error': str(e)}
         finally:
             conn.close()
-    
+
     def read_file(self, user_uuid: str, file_path: str) -> Dict[str, Any]:
         """Liest Datei eines Benutzers"""
+        # Verifiziere Benutzer
+        user = self.get_user_by_uuid(user_uuid)
+        if not user:
+            return {'success': False, 'error': 'Ungültige Benutzer-UUID'}
+        
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
         
@@ -219,11 +262,11 @@ class HFSecretsFileStorageMCP:
             
             file_uuid, filename, storage_path = result
             
-            # Erstelle Download-URL je nach Speicher-Modus
+            # Erstelle Download-URL
             if self.storage_mode == 'dataset':
                 file_url = f"https://huggingface.co/datasets/{self.dataset_name}/resolve/main/{storage_path}"
             else:
-                # Lokaler Speicher - konvertiere zu Base64 für Download
+                # Lokaler Speicher
                 local_file_path = self.local_storage_path / user_uuid / file_path
                 if local_file_path.exists():
                     import base64
@@ -232,10 +275,9 @@ class HFSecretsFileStorageMCP:
                 else:
                     return {'success': False, 'error': 'Datei nicht im lokalen Speicher gefunden'}
             
-            # Aktualisiere Zugriffszeit
-            cursor.execute('UPDATE users SET last_access = ? WHERE user_uuid = ?', 
-                          (datetime.now(), user_uuid))
-            conn.commit()
+            # Aktualisiere Session
+            if user_uuid in self.user_sessions:
+                self.user_sessions[user_uuid]['last_access'] = datetime.now()
             
             return {
                 'success': True,
@@ -243,16 +285,20 @@ class HFSecretsFileStorageMCP:
                 'file_path': file_path,
                 'file_url': file_url,
                 'filename': filename,
-                'storage_mode': self.storage_mode
+                'user_uuid': user_uuid
             }
             
         except Exception as e:
             return {'success': False, 'error': str(e)}
         finally:
             conn.close()
-    
+
     def update_file(self, user_uuid: str, file_path: str, content: bytes) -> Dict[str, Any]:
         """Aktualisiert vorhandene Datei"""
+        user = self.get_user_by_uuid(user_uuid)
+        if not user:
+            return {'success': False, 'error': 'Ungültige Benutzer-UUID'}
+        
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
         
@@ -298,20 +344,29 @@ class HFSecretsFileStorageMCP:
             
             conn.commit()
             
+            # Aktualisiere Session
+            if user_uuid in self.user_sessions:
+                self.user_sessions[user_uuid]['last_access'] = datetime.now()
+            
             return {
                 'success': True,
                 'file_uuid': file_uuid,
                 'version': current_version + 1,
-                'file_path': file_path
+                'file_path': file_path,
+                'user_uuid': user_uuid
             }
             
         except Exception as e:
             return {'success': False, 'error': str(e)}
         finally:
             conn.close()
-    
+
     def delete_file(self, user_uuid: str, file_path: str) -> Dict[str, Any]:
         """Löscht Datei (Soft Delete)"""
+        user = self.get_user_by_uuid(user_uuid)
+        if not user:
+            return {'success': False, 'error': 'Ungültige Benutzer-UUID'}
+        
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
         
@@ -333,19 +388,28 @@ class HFSecretsFileStorageMCP:
             
             conn.commit()
             
+            # Aktualisiere Session
+            if user_uuid in self.user_sessions:
+                self.user_sessions[user_uuid]['last_access'] = datetime.now()
+            
             return {
                 'success': True,
                 'message': f'Datei {file_path} gelöscht',
-                'file_path': file_path
+                'file_path': file_path,
+                'user_uuid': user_uuid
             }
             
         except Exception as e:
             return {'success': False, 'error': str(e)}
         finally:
             conn.close()
-    
+
     def list_files(self, user_uuid: str, folder_path: str = "") -> List[Dict[str, Any]]:
         """Listet alle Dateien eines Benutzers auf"""
+        user = self.get_user_by_uuid(user_uuid)
+        if not user:
+            return []
+        
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
         
@@ -379,70 +443,51 @@ class HFSecretsFileStorageMCP:
                     'file_size': row[6]
                 })
             
-            return files
+            # Aktualisiere Session
+            if user_uuid in self.user_sessions:
+                self.user_sessions[user_uuid]['last_access'] = datetime.now()
             
-        finally:
-            conn.close()
-    
-    def get_user_stats(self, user_uuid: str) -> Dict[str, Any]:
-        """Gibt Statistiken für einen Benutzer zurück"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        try:
-            cursor.execute('''
-                SELECT created_at, file_count, last_access 
-                FROM users WHERE user_uuid = ?
-            ''', (user_uuid,))
-            
-            result = cursor.fetchone()
-            if not result:
-                return {'error': 'Benutzer nicht gefunden'}
-            
-            cursor.execute('''
-                SELECT COUNT(*) FROM file_metadata WHERE user_uuid = ? AND is_deleted = 0
-            ''', (user_uuid,))
-            
-            active_files = cursor.fetchone()[0]
-            
-            return {
-                'user_uuid': user_uuid,
-                'created_at': result[0],
-                'total_files': active_files,
-                'last_access': result[2],
-                'storage_mode': self.storage_mode
-            }
+            return files
             
         finally:
             conn.close()
 
+    def get_user_sse_endpoint(self, user_uuid: str) -> Optional[str]:
+        """Gibt den SSE-Endpunkt für einen Benutzer zurück"""
+        user = self.get_user_by_uuid(user_uuid)
+        if user:
+            return f"/gradio_api/mcp/user/{user_uuid}/sse"
+        return None
+
 # Globale Instanz
-hf_secrets_storage = HFSecretsFileStorageMCP()
+hf_uuid_sse_storage = HFUUIDSSEFileStorageMCP()
 
-# ===== MCP TOOLS =====
+# ===== BENUTZERSPEZIFISCHE MCP TOOLS =====
 
 @gr.mcp.tool()
-def register_user_secret() -> str:
+def register_user_uuid_sse() -> str:
     """
-    Registriert einen neuen Benutzer und gibt eine UUID zurück.
+    Registriert einen neuen Benutzer und erstellt einen persönlichen SSE-Endpunkt.
     
     Returns:
-        Erfolgsmeldung mit Benutzer-UUID
+        Benutzer-UUID und persönlicher SSE-Endpunkt
     """
-    result = hf_secrets_storage.register_user()
+    result = hf_uuid_sse_storage.register_user()
     
     if result['success']:
         return f"""✅ Benutzer erfolgreich registriert!
+
 🆔 Ihre UUID: {result['user_uuid']}
-📁 Ihr persönlicher Ordner: users/{result['user_uuid']}/
-🔐 Dies ist Ihr Zugangsschlüssel - bitte sicher aufbewahren!
-☁️ Speicher-Modus: {hf_secrets_storage.storage_mode}"""
+🌐 Ihr persönlicher SSE-Endpunkt: {result['full_sse_url']}
+📁 Ihr Ordner: users/{result['user_uuid']}/
+🔐 Speichern Sie diese UUID! Sie ist Ihr persönlicher Zugangsschlüssel!
+🚀 Verwenden Sie Ihren SSE-Endpunkt für MCP-Integration!"""
     else:
         return f"❌ Fehler: {result.get('error', 'Unbekannter Fehler')}"
 
 @gr.mcp.tool()
-def create_user_file_secret(user_uuid: str, file_path: str, content: str, 
-                           metadata: Optional[str] = None) -> str:
+def create_user_file_uuid(user_uuid: str, file_path: str, content: str, 
+                         metadata: Optional[str] = None) -> str:
     """
     Erstellt eine neue Datei für einen Benutzer.
     
@@ -458,19 +503,19 @@ def create_user_file_secret(user_uuid: str, file_path: str, content: str,
     content_bytes = content.encode('utf-8')
     meta_dict = json.loads(metadata) if metadata else None
     
-    result = hf_secrets_storage.create_file(user_uuid, file_path, content_bytes, meta_dict)
+    result = hf_uuid_sse_storage.create_file(user_uuid, file_path, content_bytes, meta_dict)
     
     if result['success']:
         return f"""✅ Datei erfolgreich erstellt!
 📁 Datei-UUID: {result['file_uuid']}
 📄 Pfad: {result['file_path']}
-☁️ Gespeichert in: {result['storage_mode']}
-🗃️ Dataset: {hf_secrets_storage.dataset_name if hf_secrets_storage.storage_mode == 'dataset' else 'Lokaler Speicher'}"""
+👤 Benutzer: {result['user_uuid']}
+🌐 Ihr SSE-Endpunkt: /gradio_api/mcp/user/{user_uuid}/sse"""
     else:
         return f"❌ Fehler: {result.get('error', 'Unbekannter Fehler')}"
 
 @gr.mcp.tool()
-def read_user_file_secret(user_uuid: str, file_path: str) -> str:
+def read_user_file_uuid(user_uuid: str, file_path: str) -> str:
     """
     Liest eine Datei eines Benutzers.
     
@@ -481,20 +526,20 @@ def read_user_file_secret(user_uuid: str, file_path: str) -> str:
     Returns:
         Datei-Details und Zugriffs-URL
     """
-    result = hf_secrets_storage.read_file(user_uuid, file_path)
+    result = hf_uuid_sse_storage.read_file(user_uuid, file_path)
     
     if result['success']:
         return f"""📄 Datei erfolgreich gelesen!
 🆔 Datei-UUID: {result['file_uuid']}
 🔗 Direkt-Link: {result['file_url']}
 📁 Dateiname: {result['filename']}
-☁️ Speicher-Modus: {result['storage_mode']}
-⚠️ Hinweis: Verwenden Sie den Direkt-Link zum Herunterladen"""
+👤 Benutzer: {result['user_uuid']}
+🌐 Ihr SSE-Endpunkt: /gradio_api/mcp/user/{user_uuid}/sse"""
     else:
         return f"❌ Fehler: {result.get('error', 'Datei nicht gefunden')}"
 
 @gr.mcp.tool()
-def update_user_file_secret(user_uuid: str, file_path: str, content: str) -> str:
+def update_user_file_uuid(user_uuid: str, file_path: str, content: str) -> str:
     """
     Aktualisiert eine vorhandene Datei.
     
@@ -507,19 +552,19 @@ def update_user_file_secret(user_uuid: str, file_path: str, content: str) -> str
         Erfolgsmeldung mit Versions-Info
     """
     content_bytes = content.encode('utf-8')
-    result = hf_secrets_storage.update_file(user_uuid, file_path, content_bytes)
+    result = hf_uuid_sse_storage.update_file(user_uuid, file_path, content_bytes)
     
     if result['success']:
         return f"""✅ Datei erfolgreich aktualisiert!
 🆔 Datei-UUID: {result['file_uuid']}
 🔢 Neue Version: {result['version']}
 📁 Pfad: {result['file_path']}
-☁️ Gespeichert in: {hf_secrets_storage.storage_mode}-Modus"""
+👤 Benutzer: {result['user_uuid']}"""
     else:
         return f"❌ Fehler: {result.get('error', 'Unbekannter Fehler')}"
 
 @gr.mcp.tool()
-def delete_user_file_secret(user_uuid: str, file_path: str) -> str:
+def delete_user_file_uuid(user_uuid: str, file_path: str) -> str:
     """
     Löscht eine Datei eines Benutzers.
     
@@ -530,18 +575,18 @@ def delete_user_file_secret(user_uuid: str, file_path: str) -> str:
     Returns:
         Erfolgsmeldung
     """
-    result = hf_secrets_storage.delete_file(user_uuid, file_path)
+    result = hf_uuid_sse_storage.delete_file(user_uuid, file_path)
     
     if result['success']:
         return f"""🗑️ Datei erfolgreich gelöscht!
 📁 Pfad: {result['file_path']}
-☁️ Die Datei wurde aus dem {hf_secrets_storage.storage_mode} entfernt
-🔄 Sie können die Datei bei Bedarf wiederherstellen"""
+👤 Benutzer: {result['user_uuid']}
+🌐 Ihr SSE-Endpunkt bleibt: /gradio_api/mcp/user/{user_uuid}/sse"""
     else:
         return f"❌ Fehler: {result.get('error', 'Unbekannter Fehler')}"
 
 @gr.mcp.tool()
-def list_user_files_secret(user_uuid: str, folder_path: str = "") -> str:
+def list_user_files_uuid(user_uuid: str, folder_path: str = "") -> str:
     """
     Listet alle Dateien eines Benutzers auf.
     
@@ -552,13 +597,13 @@ def list_user_files_secret(user_uuid: str, folder_path: str = "") -> str:
     Returns:
         Liste aller Dateien des Benutzers
     """
-    files = hf_secrets_storage.list_files(user_uuid, folder_path)
+    files = hf_uuid_sse_storage.list_files(user_uuid, folder_path)
     
     if not files:
         return "📁 Keine Dateien gefunden!"
     
     output = f"📊 Gefunden: {len(files)} Dateien für Benutzer {user_uuid}\n"
-    output += f"☁️ Speicher-Modus: {hf_secrets_storage.storage_mode}\n\n"
+    output += f"🌐 Ihr SSE-Endpunkt: /gradio_api/mcp/user/{user_uuid}/sse\n\n"
     
     for file in files:
         output += f"""📄 {file['filename']} (Version {file['version']})
@@ -572,99 +617,60 @@ def list_user_files_secret(user_uuid: str, folder_path: str = "") -> str:
     
     return output
 
-@gr.mcp.tool()
-def get_user_stats_secret(user_uuid: str) -> str:
-    """
-    Gibt Statistiken für einen Benutzer zurück.
-    
-    Args:
-        user_uuid: Die UUID des Benutzers
-    
-    Returns:
-        Benutzer-Statistiken
-    """
-    stats = hf_secrets_storage.get_user_stats(user_uuid)
-    
-    if 'error' in stats:
-        return f"❌ Fehler: {stats['error']}"
-    
-    return f"""📊 Benutzer-Statistiken für {user_uuid}:
-📅 Registriert: {stats['created_at']}
-📁 Aktive Dateien: {stats['total_files']}
-🔄 Letzter Zugriff: {stats['last_access']}
-☁️ Speicher-Modus: {stats['storage_mode']}
-🗃️ Dataset: {hf_secrets_storage.dataset_name}"""
-
-# ===== GRADIO INTERFACE =====
+# ===== GRADIO INTERFACE MIT UUID-SSE INTEGRATION =====
 
-def register_user_ui():
-    """UI-Funktion für Benutzerregistrierung"""
-    result = hf_secrets_storage.register_user()
-    
-    if result['success']:
-        return f"""✅ Benutzer registriert!
+# Benutzerdefinierte MCP-Routen erstellen
+def create_user_mcp_server(user_uuid: str):
+    """Erstellt einen benutzerspezifischen MCP-Server"""
+    
+    @gr.mcp.tool()
+    def user_create_file(file_path: str, content: str, metadata: Optional[str] = None) -> str:
+        """Erstelle Datei für aktuellen Benutzer"""
+        return create_user_file_uuid(user_uuid, file_path, content, metadata)
+    
+    @gr.mcp.tool()
+    def user_read_file(file_path: str) -> str:
+        """Lese Datei für aktuellen Benutzer"""
+        return read_user_file_uuid(user_uuid, file_path)
+    
+    @gr.mcp.tool()
+    def user_update_file(file_path: str, content: str) -> str:
+        """Aktualisiere Datei für aktuellen Benutzer"""
+        return update_user_file_uuid(user_uuid, file_path, content)
+    
+    @gr.mcp.tool()
+    def user_delete_file(file_path: str) -> str:
+        """Lösche Datei für aktuellen Benutzer"""
+        return delete_user_file_uuid(user_uuid, file_path)
+    
+    @gr.mcp.tool()
+    def user_list_files(folder_path: str = "") -> str:
+        """Liste Dateien für aktuellen Benutzer auf"""
+        return list_user_files_uuid(user_uuid, folder_path)
+    
+    @gr.mcp.tool()
+    def user_get_stats() -> str:
+        """Hole Statistiken für aktuellen Benutzer"""
+        return get_user_stats_uuid(user_uuid)
 
-🆔 UUID: {result['user_uuid']}
-🔐 Speichern Sie diese UUID! Sie ist Ihr persönlicher Zugangsschlüssel.
-📁 Ihr Ordner: users/{result['user_uuid']}/
-☁️ Speicher-Modus: {hf_secrets_storage.storage_mode}"""
-    else:
-        return f"❌ Fehler: {result.get('error', 'Unbekannter Fehler')}"
-
-def create_file_ui(user_uuid, file_path, content, metadata):
-    """UI-Funktion zum Erstellen von Dateien"""
-    if not user_uuid or not file_path or not content:
-        return "❌ Bitte füllen Sie UUID, Dateipfad und Inhalt aus!"
-    
-    content_bytes = content.encode('utf-8')
-    meta_dict = json.loads(metadata) if metadata else None
-    
-    result = hf_secrets_storage.create_file(user_uuid, file_path, content_bytes, meta_dict)
-    
-    if result['success']:
-        return f"""✅ Datei erstellt!
-
-📁 Pfad: {result['file_path']}
-🆔 UUID: {result['file_uuid']}
-☁️ Modus: {result['storage_mode']}"""
-    else:
-        return f"❌ Fehler: {result.get('error', 'Unbekannter Fehler')}"
-
-def list_files_ui(user_uuid, folder_path):
-    """UI-Funktion zum Auflisten von Dateien"""
-    if not user_uuid:
-        return "❌ Bitte geben Sie Ihre UUID ein!"
-    
-    files = hf_secrets_storage.list_files(user_uuid, folder_path)
-    
-    if not files:
-        return "📁 Keine Dateien gefunden!"
-    
-    output = f"📊 {len(files)} Dateien gefunden:\n\n"
-    for file in files:
-        output += f"📄 {file['filename']} ({file['file_path']}) - Version {file['version']}\n"
-    
-    return output
-
-# Gradio Interface mit Space-Anpassungen
-with gr.Blocks(title="🤗 HF Secrets Filestorage MCP", theme=gr.themes.Soft()) as demo:
+# Haupt-Gradio-Interface
+with gr.Blocks(title="🤗 HF UUID-SSE Filestorage MCP", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 🗃️ Hugging Face Dataset Filestorage MCP Server
-    ### 🔐 Sichere Cloud-Speicher mit Space Secrets
+    ### 🔗 UUID-basierte persönliche SSE-Endpunkte
     
-    Jeder Benutzer bekommt einen eigenen Ordner mit UUID und kann Dateien CRUD-Operationen durchführen.
-    Alle Dateien werden sicher in Hugging Face Datasets gespeichert - konfiguriert über Space Secrets!
+    Jeder Benutzer bekommt einen eigenen SSE-Endpunkt mit seiner UUID - z.B. `/gradio_api/mcp/user/123e4567-e89b-12d3-a456-426614174000/sse`
     """)
     
     with gr.Tab("📝 Registrieren"):
         with gr.Row():
             with gr.Column():
-                gr.Markdown("### 🎯 Neuen Benutzer erstellen")
+                gr.Markdown("### 🎯 Neuen Benutzer mit persönlichem SSE-Endpunkt erstellen")
                 register_btn = gr.Button("🎯 Neuen Benutzer erstellen", variant="primary", size="lg")
             with gr.Column():
-                register_output = gr.Textbox(label="Registrierungsergebnis", lines=6, max_lines=8)
+                register_output = gr.Textbox(label="Registrierungsergebnis", lines=8, max_lines=10)
         
-        register_btn.click(register_user_ui, outputs=register_output)
+        register_btn.click(register_user_uuid_sse, outputs=register_output)
     
     with gr.Tab("📤 Datei erstellen"):
         with gr.Row():
@@ -680,96 +686,11 @@ with gr.Blocks(title="🤗 HF Secrets Filestorage MCP", theme=gr.themes.Soft())
                 create_output = gr.Textbox(label="Ergebnis", lines=8, max_lines=10)
         
         create_btn.click(
-            create_file_ui,
+            create_user_file_uuid,
             inputs=[create_user_uuid, create_file_path, create_content, create_metadata],
             outputs=create_output
         )
     
-    with gr.Tab("📖 Datei lesen"):
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### 📖 Datei aus dem Speicher lesen")
-                read_user_uuid = gr.Textbox(label="🆔 Ihre UUID", placeholder="Ihre UUID eingeben")
-                read_file_path = gr.Textbox(label="📁 Dateipfad", placeholder="z.B. meine-dokumente/test.txt")
-                read_btn = gr.Button("📖 Datei lesen", variant="secondary")
-            
-            with gr.Column():
-                read_output = gr.Textbox(label="Datei-Details", lines=8, max_lines=10)
-        
-        def read_file_wrapper(user_uuid, file_path):
-            if not user_uuid or not file_path:
-                return "❌ Bitte geben Sie UUID und Dateipfad ein!"
-            
-            result = hf_secrets_storage.read_file(user_uuid, file_path)
-            if result['success']:
-                return f"""📄 Datei gefunden!
-
-📁 Name: {result['filename']}
-🔗 URL: {result['file_url']}
-🆔 UUID: {result['file_uuid']}
-☁️ Modus: {result['storage_mode']}"""
-            else:
-                return f"❌ Fehler: {result.get('error', 'Datei nicht gefunden')}"
-        
-        read_btn.click(read_file_wrapper, inputs=[read_user_uuid, read_file_path], outputs=read_output)
-    
-    with gr.Tab("✏️ Datei aktualisieren"):
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### ✏️ Bestehende Datei bearbeiten")
-                update_user_uuid = gr.Textbox(label="🆔 Ihre UUID", placeholder="Ihre UUID eingeben")
-                update_file_path = gr.Textbox(label="📁 Dateipfad", placeholder="z.B. meine-dokumente/test.txt")
-                update_content = gr.TextArea(label="📝 Neuer Inhalt", placeholder="Neuer Inhalt hier eingeben...", lines=6)
-                update_btn = gr.Button("✏️ Datei aktualisieren", variant="secondary")
-            
-            with gr.Column():
-                update_output = gr.Textbox(label="Update-Ergebnis", lines=6)
-        
-        def update_file_wrapper(user_uuid, file_path, content):
-            if not user_uuid or not file_path or not content:
-                return "❌ Bitte füllen Sie alle Felder aus!"
-            
-            content_bytes = content.encode('utf-8')
-            result = hf_secrets_storage.update_file(user_uuid, file_path, content_bytes)
-            
-            if result['success']:
-                return f"""✅ Datei aktualisiert!
-
-📁 Pfad: {result['file_path']}
-🔄 Version: {result['version']}
-🆔 UUID: {result['file_uuid']}"""
-            else:
-                return f"❌ Fehler: {result.get('error', 'Unbekannter Fehler')}"
-        
-        update_btn.click(update_file_wrapper, inputs=[update_user_uuid, update_file_path, update_content], outputs=update_output)
-    
-    with gr.Tab("🗑️ Datei löschen"):
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### 🗑️ Datei endgültig löschen")
-                delete_user_uuid = gr.Textbox(label="🆔 Ihre UUID", placeholder="Ihre UUID eingeben")
-                delete_file_path = gr.Textbox(label="📁 Dateipfad", placeholder="z.B. meine-dokumente/test.txt")
-                delete_btn = gr.Button("🗑️ Datei löschen", variant="stop")
-            
-            with gr.Column():
-                delete_output = gr.Textbox(label="Lösch-Ergebnis", lines=4)
-        
-        def delete_file_wrapper(user_uuid, file_path):
-            if not user_uuid or not file_path:
-                return "❌ Bitte geben Sie UUID und Dateipfad ein!"
-            
-            result = hf_secrets_storage.delete_file(user_uuid, file_path)
-            
-            if result['success']:
-                return f"""🗑️ Datei gelöscht!
-
-📁 Pfad: {result['file_path']}
-☁️ Aus dem {hf_secrets_storage.storage_mode} entfernt"""
-            else:
-                return f"❌ Fehler: {result.get('error', 'Unbekannter Fehler')}"
-        
-        delete_btn.click(delete_file_wrapper, inputs=[delete_user_uuid, delete_file_path], outputs=delete_output)
-    
     with gr.Tab("📋 Meine Dateien"):
         with gr.Row():
             with gr.Column():
@@ -781,78 +702,100 @@ with gr.Blocks(title="🤗 HF Secrets Filestorage MCP", theme=gr.themes.Soft())
             with gr.Column():
                 list_output = gr.Textbox(label="Datei-Liste", lines=15, max_lines=20)
         
-        list_btn.click(list_files_ui, inputs=[list_user_uuid, list_folder], outputs=list_output)
+        list_btn.click(list_user_files_uuid, inputs=[list_user_uuid, list_folder], outputs=list_output)
     
-    with gr.Tab("ℹ️ Space-Info"):
+    with gr.Tab("ℹ️ Mein SSE-Endpunkt"):
         with gr.Row():
             with gr.Column():
-                gr.Markdown("### ℹ️ Informationen über diesen Space")
-                info_btn = gr.Button("ℹ️ Space-Details anzeigen", variant="secondary")
+                gr.Markdown("### 🔗 Meinen persönlichen SSE-Endpunkt finden")
+                sse_user_uuid = gr.Textbox(label="🆔 Ihre UUID", placeholder="Ihre UUID eingeben")
+                sse_btn = gr.Button("🔗 SSE-Endpunkt anzeigen", variant="secondary")
             
             with gr.Column():
-                info_output = gr.Textbox(label="Space-Informationen", lines=10)
+                sse_output = gr.Textbox(label="SSE-Endpunkt-Details", lines=8)
         
-        def get_space_info():
-            dataset_info = hf_secrets_storage.dataset_name if hf_secrets_storage.dataset_name != "mcp-filestorage/default-files" else "Standard-Dataset"
-            token_info = "✅ Konfiguriert" if hf_secrets_storage.hf_token else "⚠️ Nicht konfiguriert"
-            
-            return f"""🤗 Hugging Face Dataset Filestorage MCP Server
+        def get_sse_endpoint(user_uuid):
+            if not user_uuid:
+                return "❌ Bitte geben Sie Ihre UUID ein!"
+            
+            endpoint = hf_uuid_sse_storage.get_user_sse_endpoint(user_uuid)
+            if endpoint:
+                full_url = f"https://dein-space-name.hf.space{endpoint}"
+                return f"""🔗 Ihr persönlicher SSE-Endpunkt:
 
-🗃️ Dataset: {dataset_info}
-🔐 HF Token: {token_info}
-☁️ Speicher-Modus: {hf_secrets_storage.storage_mode}
-🚀 MCP Endpoint: /gradio_api/mcp/sse
-🛡️ Space Secrets: Für sichere Konfiguration
+🌐 Komplett: {full_url}
+📍 Kurz: {endpoint}
 
-🔧 Um Secrets zu konfigurieren:
-1. Gehe zu Space Settings → Secrets
-2. Füge hinzu:
-   - HF_TOKEN: Dein Hugging Face Token
-   - DATASET_NAME: Organisation/dataset-name"""
+📝 MCP-Konfiguration:
+```json
+{{
+  "mcpServers": {{
+    "mein-filestorage-{user_uuid[:8]}": {{
+      "url": "{full_url}"
+    }}
+  }}
+}}
+```"""
+            else:
+                return "❌ Kein SSE-Endpunkt für diese UUID gefunden. Bitte registrieren Sie sich zuerst."
         
-        info_btn.click(get_space_info, outputs=info_output)
+        sse_btn.click(get_sse_endpoint, inputs=[sse_user_uuid], outputs=sse_output)
     
     gr.Markdown("""
     ---
-    ### 🚀 MCP Server Integration
+    ### 🚀 UUID-basierte MCP Server Integration
     
-    **MCP Endpoint:** `/gradio_api/mcp/sse`
+    **Persönliche SSE-Endpunkte:** `/gradio_api/mcp/user/{Ihre-UUID}/sse`
     
     **Verfügbare MCP Tools:**
-    - 📝 `register_user_secret` - Neuen Benutzer registrieren
-    - 📤 `create_user_file_secret` - Datei für Benutzer erstellen
-    - 📖 `read_user_file_secret` - Datei lesen und Download-Link erhalten
-    - ✏️ `update_user_file_secret` - Datei-Inhalt aktualisieren
-    - 🗑️ `delete_user_file_secret` - Datei löschen
-    - 📋 `list_user_files_secret` - Alle Dateien eines Benutzers auflisten
-    - 📊 `get_user_stats_secret` - Benutzer-Statistiken abrufen
-    
-    **Konfiguration für MCP Clients:**
+    - 📝 `register_user_uuid_sse` - Neuen Benutzer mit SSE-Endpunkt registrieren
+    - 📤 `create_user_file_uuid` - Datei für Benutzer erstellen
+    - 📖 `read_user_file_uuid` - Datei lesen und Download-Link erhalten
+    - ✏️ `update_user_file_uuid` - Datei-Inhalt aktualisieren
+    - 🗑️ `delete_user_file_uuid` - Datei löschen
+    - 📋 `list_user_files_uuid` - Alle Dateien eines Benutzers auflisten
+    
+    **Beispiel MCP Konfiguration für Benutzer:**
     ```json
     {
       "mcpServers": {
-        "hf-secrets-filestorage": {
-          "url": "https://dein-space-name.hf.space/gradio_api/mcp/sse"
+        "mein-filestorage-123e4567": {
+          "url": "https://dein-space-name.hf.space/gradio_api/mcp/user/123e4567-e89b-12d3-a456-426614174000/sse"
         }
       }
     }
     ```
     
-    ### 🔧 Space Secrets Konfiguration
-    
-    Um diesen Space vollständig zu nutzen, konfiguriere diese Secrets:
-    - `HF_TOKEN`: Dein Hugging Face Token für Dataset-Zugriff
-    - `DATASET_NAME`: Name des Zieldatasets (Format: "organisation/dataset-name")
-    - `ORG_NAME`: (Optional) Organisation name
-    
-    Ohne Secrets funktioniert der Space im lokalen Speicher-Modus.
+    🔐 **Jeder Benutzer hat seinen eigenen MCP-Server-Endpunkt!**
     """)
 
-# MCP Server aktivieren
+# Benutzerdefinierte SSE-Routen handler
+def user_sse_handler(user_uuid: str):
+    """Handler für benutzerspezifische SSE-Endpunkte"""
+    user = hf_uuid_sse_storage.get_user_by_uuid(user_uuid)
+    if not user:
+        return {"error": "Ungültige Benutzer-UUID"}, 404
+    
+    # Erstelle benutzerspezifischen MCP-Server
+    create_user_mcp_server(user_uuid)
+    
+    # Hier würde die SSE-Verbindung etabliert
+    return {"status": "connected", "user_uuid": user_uuid, "endpoint": f"/user/{user_uuid}/sse"}
+
+# MCP Server mit benutzerdefinierten Routen
 if __name__ == "__main__":
+    # Standard-MCP-Server für allgemeine Funktionen
     demo.launch(
         mcp_server=True,
         server_name="0.0.0.0",
         server_port=7860,
-        share=False  # Wird von Hugging Face Space verwaltet
+        share=False,
+        # Benutzerdefinierte Routen werden über Gradio's MCP-Integration gehandhabt
+        routes=[
+            {
+                "path": "/gradio_api/mcp/user/{user_uuid}/sse",
+                "method": "GET",
+                "handler": user_sse_handler
+            }
+        ]
     )