🔒 Remove API token from code - use environment variables

app.py

@@ -1,70 +1,147 @@
 import gradio as gr
 import requests
 import time
+import os
 from datetime import datetime
 
-class HuggingFaceSimpleBenchmark:
+class HuggingFaceRealAPI:
     def __init__(self):
-        # Verwende kleinere, öffentlich verfügbare Models
-        self.demo_models = {
-            "GPT-2 Small": {"response_time": 1.5, "tokens": 85},
-            "DistilGPT-2": {"response_time": 0.8, "tokens": 72},  
-            "T5-Small": {"response_time": 2.1, "tokens": 95}
-        }
+        # API-Token aus Environment oder direkt einsetzen
+        self.api_token = os.getenv("HF_TOKEN", None)  # ← Token hier einsetzen
+        self.api_url = "https://api-inference.huggingface.co/models/"
         
-    def simulate_cloud_response(self, prompt, model_name, agent_role="General"):
-        """Simuliert Cloud-Performance basierend auf typischen HuggingFace Daten"""
+        # Models die definitiv funktionieren
+        self.available_models = [
+            "gpt2",
+            "distilgpt2",
+            "microsoft/DialoGPT-small"
+        ]
         
-        # SAAP-spezifische Prompts
-        saap_prompts = {
-            "Jane": f"Als KI-Architektin für Multi-Agent-Systeme: {prompt}",
-            "John": f"Als Softwareentwickler für AGI-Architekturen: {prompt}",
-            "Justus": f"Als Rechtsexperte für DSGVO und KI-Compliance: {prompt}",
-            "General": prompt
+    def query_model(self, model_name, prompt):
+        """Echter API Call mit Authentication"""
+        url = f"{self.api_url}{model_name}"
+        
+        headers = {
+            "Authorization": f"Bearer {self.api_token}",
+            "Content-Type": "application/json"
         }
         
-        final_prompt = saap_prompts.get(agent_role, prompt)
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": 100,
+                "temperature": 0.7,
+                "do_sample": True,
+                "return_full_text": False
+            },
+            "options": {
+                "wait_for_model": True  # Wichtig: Warten bis Model geladen ist
+            }
+        }
         
-        # Simuliere typische Cloud-Performance
-        model_data = self.demo_models.get(model_name, {"response_time": 2.0, "tokens": 80})
+        response = requests.post(url, headers=headers, json=payload, timeout=60)
+        return response
+
+    def test_agent_response(self, prompt, model_name, agent_role="General"):
+        """Echter HuggingFace API Test"""
         
-        # Simuliere API Call mit realistischen Zeiten
-        start_time = time.time()
-        time.sleep(model_data["response_time"])  # Simuliere Processing-Zeit
-        end_time = time.time()
-        
-        # Simuliere typische Cloud-Responses
-        sample_responses = {
-            "Jane": f"On-Premise Multi-Agent-Plattformen bieten mehrere Vorteile: 1) Vollständige Datenkontrolle und DSGVO-Compliance, 2) Keine laufenden Cloud-Kosten, 3) Offline-Betrieb möglich, 4) Anpassbare Hardware-Konfiguration...",
-            "John": f"Aus Entwicklersicht ermöglichen On-Premise-Systeme: 1) Direkte Hardware-Kontrolle, 2) Angepasste Optimierungen, 3) Keine Latenz durch Netzwerk-Calls, 4) Vollständige Code- und Deployment-Kontrolle...",
-            "Justus": f"Rechtlich bieten On-Premise-Lösungen: 1) Vollständige DSGVO-Compliance ohne Datenübertragung, 2) Keine Abhängigkeit von Drittanbietern, 3) Kontrolle über Datenverarbeitung und -speicherung...",
-            "General": f"On-Premise Multi-Agent-Plattformen bieten Unternehmen vollständige Kontrolle über ihre KI-Infrastruktur, Datenschutz-Compliance und Kosteneffizienz bei hohem Durchsatz."
+        saap_prompts = {
+            "Jane": f"Als KI-Architektin für Multi-Agent-Systeme:\nFrage: {prompt}\nAntwort:",
+            "John": f"Als Softwareentwickler für AGI-Architekturen:\nFrage: {prompt}\nAntwort:", 
+            "Justus": f"Als Rechtsexperte für DSGVO:\nFrage: {prompt}\nAntwort:",
+            "General": f"Frage: {prompt}\nAntwort:"
         }
         
-        response_text = sample_responses.get(agent_role, sample_responses["General"])
+        final_prompt = saap_prompts.get(agent_role, prompt)
+        start_time = time.time()
         
-        return {
-            "response": response_text,
-            "time": f"{end_time - start_time:.2f}s",
-            "model": model_name,
-            "tokens": model_data["tokens"],
-            "status": "✅ Success (Cloud Simulation)",
-            "environment": "☁️ HuggingFace GPU Cluster (Simulated)"
-        }
+        try:
+            response = self.query_model(model_name, final_prompt)
+            end_time = time.time()
+            response_time = end_time - start_time
+            
+            if response.status_code == 200:
+                result = response.json()
+                
+                # Handle verschiedene Response-Formate
+                if isinstance(result, list) and len(result) > 0:
+                    if 'generated_text' in result[0]:
+                        response_text = result[0]['generated_text']
+                    else:
+                        response_text = str(result[0])
+                elif isinstance(result, dict):
+                    if 'generated_text' in result:
+                        response_text = result['generated_text'] 
+                    elif 'error' in result:
+                        return {
+                            "status": f"❌ API Error: {result['error']}",
+                            "time": f"{response_time:.2f}s"
+                        }
+                    else:
+                        response_text = str(result)
+                else:
+                    response_text = str(result)
+                
+                return {
+                    "response": response_text,
+                    "time": f"{response_time:.2f}s",
+                    "model": model_name,
+                    "tokens": len(response_text.split()),
+                    "status": "✅ Success (Echte HuggingFace API)",
+                    "environment": "☁️ HuggingFace GPU Cluster"
+                }
+                
+            elif response.status_code == 503:
+                return {
+                    "status": "⏳ Model Loading - Versuche es in 30s erneut",
+                    "time": f"{response_time:.2f}s"
+                }
+            else:
+                error_text = response.text[:100] if response.text else f"HTTP {response.status_code}"
+                return {
+                    "status": f"❌ API Error: {error_text}",
+                    "time": f"{response_time:.2f}s"
+                }
+                
+        except requests.exceptions.Timeout:
+            return {
+                "status": "❌ Timeout - Model zu langsam",
+                "time": f"{time.time() - start_time:.2f}s"
+            }
+        except Exception as e:
+            return {
+                "status": f"❌ Error: {str(e)[:50]}",
+                "time": f"{time.time() - start_time:.2f}s"
+            }
 
-benchmark = HuggingFaceSimpleBenchmark()
+# Global benchmark instance
+benchmark = HuggingFaceRealAPI()
 
 def run_cloud_benchmark(prompt, selected_models, agent_role):
-    """Cloud Performance Simulation für SAAP Thesis"""
+    """Echter Cloud Benchmark mit HuggingFace API"""
     if not prompt.strip():
         return "⚠️ **Bitte Test-Prompt eingeben**"
     
     if not selected_models:
         return "⚠️ **Bitte mindestens ein Model auswählen**"
     
+    # Token-Check
+    if "YOUR_TOKEN_HERE" in benchmark.api_token:
+        return """
+        ## ❌ HuggingFace API Token benötigt
+        
+        **Für echte API-Calls:**
+        1. Gehe zu https://huggingface.co/settings/tokens
+        2. Erstelle neuen "Read" Token  
+        3. Ersetze `hf_YOUR_TOKEN_HERE` in der app.py
+        4. Neu deployen
+        
+        **Ohne Token sind nur lokale Tests möglich.**
+        """
+    
     results = []
-    results.append("# ☁️ SAAP Cloud Performance Benchmark")
-    results.append("**Platform:** HuggingFace GPU Cloud (Performance Simulation)")
+    results.append("# ☁️ SAAP Cloud Performance Benchmark (ECHT)")
+    results.append("**Platform:** HuggingFace Inference API | **Echte GPU-Cluster**")
     results.append(f"**🤖 Agent Role:** {agent_role}")
     results.append(f"**📝 Test Prompt:** {prompt}")
     results.append(f"**🔧 Models:** {', '.join(selected_models)}")
@@ -75,116 +152,95 @@ def run_cloud_benchmark(prompt, selected_models, agent_role):
     successful_tests = 0
     
     for model_name in selected_models:
-        result = benchmark.simulate_cloud_response(prompt, model_name, agent_role)
+        result = benchmark.test_agent_response(prompt, model_name, agent_role)
         
         results.append(f"## ☁️ {model_name}")
         results.append(f"**Status:** {result.get('status', '❌ Error')}")
         results.append(f"**Response Time:** {result.get('time', 'N/A')}")
-        results.append(f"**Environment:** {result.get('environment', 'Unknown')}")
+        results.append(f"**Environment:** {result.get('environment', '☁️ HuggingFace')}")
         results.append(f"**Tokens Generated:** {result.get('tokens', 0)}")
         
         if 'response' in result and result['response']:
             preview = result['response'][:120].replace('\n', ' ')
-            results.append(f"**Response Preview:** {preview}...")
+            results.append(f"**Echte API Response:** {preview}...")
         
         results.append("---")
         
-        # Statistics
-        successful_tests += 1
-        time_val = float(result.get('time', '0').rstrip('s'))
-        total_time += time_val
+        # Statistics nur bei Success
+        if result.get('status', '').startswith('✅'):
+            successful_tests += 1
+            try:
+                time_val = float(result.get('time', '0').rstrip('s'))
+                total_time += time_val
+            except:
+                pass
     
-    # Performance Summary mit echten Daten-Vergleich
+    # Performance Summary mit echten Daten
     if successful_tests > 0:
         avg_time = total_time / successful_tests
-        results.append(f"## 📊 Cloud Performance Summary")
+        results.append(f"## 📊 Echte Cloud Performance")
         results.append(f"**Average Response Time:** {avg_time:.2f}s")
         results.append(f"**Successful Tests:** {successful_tests}/{len(selected_models)}")
-        results.append(f"**Infrastructure:** ☁️ GPU-optimized Cloud Cluster")
-        
-        # KRITISCHER VERGLEICH mit deinen echten Daten
-        results.append(f"\n## 🆚 **SAAP Thesis: Entscheidender Performance-Vergleich**")
-        
-        results.append(f"### 🏠 **On-Premise (Deine echten CachyOS Messwerte):**")
-        results.append(f"- **qwen2:1.5b (1.5B Parameter):** 25.94s")
-        results.append(f"- **tinyllama (1B Parameter):** 17.96s")
-        results.append(f"- **Hardware:** Intel i7-5600U, 16GB RAM, keine GPU")
-        results.append(f"- **Durchschnitt:** ~22s für komplexe Agent-Prompts")
-        results.append(f"- **Kosten:** 0€ pro Request ✅")
-        results.append(f"- **DSGVO:** 100% konform, keine Datenübertragung ✅")
-        results.append(f"- **Verfügbarkeit:** Offline-fähig ✅")
-        results.append(f"- **Kontrolle:** Vollständige Datensouveränität ✅")
-        
-        results.append(f"### ☁️ **Cloud (Simulierte HuggingFace Performance):**")
-        results.append(f"- **Durchschnitt:** {avg_time:.2f}s für ähnliche Modell-Komplexität")
-        results.append(f"- **Hardware:** GPU-Cluster, professionelle Cloud-Infrastruktur")
-        results.append(f"- **Kosten:** $0.002-0.01 pro 1K Tokens (≈ $0.20-1.00 pro Request) 💰")
-        results.append(f"- **DSGVO:** Abhängig von Provider, Datenübertragung erforderlich ⚠️")
-        results.append(f"- **Verfügbarkeit:** Internetverbindung + API-Verfügbarkeit erforderlich ❌")
-        results.append(f"- **Kontrolle:** Eingeschränkt, abhängig von Provider-Policies ⚠️")
-        
-        # Dynamische Thesis-Schlussfolgerung
+        results.append(f"**Authentisch:** ✅ Echte HuggingFace GPU-Inferenz")
+        
+        # Echter Vergleich mit deinen lokalen Daten
+        results.append(f"\n## 🆚 **Authentischer Performance-Vergleich**")
+        
+        results.append(f"### 🏠 **On-Premise (Deine gemessenen Werte):**")
+        results.append(f"- **qwen2:1.5b:** 25.94s")
+        results.append(f"- **tinyllama:** 17.96s")
+        results.append(f"- **Durchschnitt:** ~22s")
+        
+        results.append(f"### ☁️ **Cloud (Echte HuggingFace API):**")
+        results.append(f"- **Durchschnitt:** {avg_time:.2f}s")
+        
+        # Echter Speedup-Vergleich
         speedup = 22 / avg_time if avg_time > 0 else 1
-        cost_per_request = avg_time * 0.1  # Simulation der API-Kosten
-        
-        results.append(f"\n### 🎓 **SAAP Master-Thesis Schlussfolgerungen:**")
-        
-        if speedup > 10:
-            results.append(f"**Performance:** ☁️ Cloud dramatisch schneller ({speedup:.1f}x), aber hohe Kosten")
-            results.append(f"**Empfehlung:** Hybrid-Ansatz - Cloud für Prototyping, On-Premise für Produktion")
-        elif speedup > 3:
-            results.append(f"**Performance:** ☁️ Cloud deutlich schneller ({speedup:.1f}x)")
-            results.append(f"**Kosten-Benefit:** Bei >100 Requests/Tag ist On-Premise günstiger")
-            results.append(f"**Empfehlung:** On-Premise für datensensible + kosteneffiziente Anwendungen")
-        elif speedup > 1.5:
-            results.append(f"**Performance:** ☁️ Cloud moderater Vorteil ({speedup:.1f}x)")
-            results.append(f"**Empfehlung:** 🏠 On-Premise vorzuziehen - ähnliche Performance + bessere Kontrolle")
+        results.append(f"\n**🎓 Authentische Thesis-Ergebnisse:**")
+        results.append(f"**Performance-Faktor:** {speedup:.1f}x ({'Cloud schneller' if speedup > 1 else 'On-Premise schneller'})")
+        
+        if speedup > 5:
+            results.append(f"**Fazit:** ☁️ Cloud deutlich überlegen ({speedup:.1f}x), aber Kosten/Datenschutz beachten")
+        elif speedup > 2:
+            results.append(f"**Fazit:** ☁️ Cloud schneller, On-Premise für Datenschutz/Kosten besser")
         else:
-            results.append(f"**Performance:** 🏠 On-Premise konkurrenzfähig oder besser")
-            results.append(f"**Empfehlung:** 🏠 On-Premise klar überlegen - bessere Performance + Datenschutz + Kosteneffizienz")
-            
-        results.append(f"\n**💡 SAAP Multi-Agent Platform Strategie:**")
-        results.append(f"- **Entwicklung/Prototyping:** ☁️ Cloud für schnelle Experimente")
-        results.append(f"- **Produktion (Datenschutz-kritisch):** 🏠 On-Premise für DSGVO-Compliance")  
-        results.append(f"- **Enterprise-Deployment:** 🏠 On-Premise für Kostenkontrolle bei hohem Durchsatz")
-        results.append(f"- **Skalierungs-Spitzen:** ☁️ Cloud als temporäre Erweiterung")
-        
-        results.append(f"\n**📊 Quantifizierte Kostenanalyse (1000 Requests/Monat):**")
-        results.append(f"- **On-Premise:** ~0€ (nach Hardware-Amortisation)")
-        results.append(f"- **Cloud:** ~${cost_per_request*1000:.0f}/Monat")
-        results.append(f"- **Break-Even:** Nach {int(2000/(cost_per_request*1000*12))} Jahren Hardware-Investition amortisiert")
+            results.append(f"**Fazit:** 🏠 On-Premise konkurrenzfähig + Datenschutz + Kostenvorteile")
+    
+    else:
+        results.append("## ❌ Keine erfolgreichen API-Calls")
+        results.append("**Mögliche Ursachen:** Token-Problem, Model-Loading, Rate-Limits")
     
     return "\n".join(results)
 
 # Gradio Interface
-with gr.Blocks(title="SAAP Cloud Benchmark", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# ☁️ SAAP Cloud Performance Benchmark")
-    gr.Markdown("**Master Thesis:** Hanan Wandji Danga | **Cloud vs. On-Premise Performance Analysis**")
+with gr.Blocks(title="SAAP Real Cloud Benchmark", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# ☁️ SAAP Echter Cloud Performance Benchmark")
+    gr.Markdown("**Master Thesis:** Hanan Wandji Danga | **Echte HuggingFace API vs. On-Premise**")
     
     with gr.Row():
         with gr.Column(scale=2):
             prompt_input = gr.Textbox(
                 label="SAAP Test Prompt",
                 lines=3,
-                value="Erkläre die Vorteile einer On-Premise Multi-Agent-Plattform gegenüber Cloud-Lösungen."
+                value="Erkläre die Vorteile einer On-Premise Multi-Agent-Plattform."
             )
             
             agent_role = gr.Dropdown(
                 choices=["General", "Jane", "John", "Justus"],
-                label="Agent Role Simulation", 
+                label="Agent Role Simulation",
                 value="Jane"
             )
             
         with gr.Column(scale=1):
             model_selection = gr.CheckboxGroup(
-                choices=list(benchmark.demo_models.keys()),
-                label="☁️ Cloud Models (Simulated)",
-                value=["GPT-2 Small", "DistilGPT-2"]
+                choices=benchmark.available_models,
+                label="☁️ Echte Cloud Models",
+                value=["gpt2"]  # Start mit einem Model
             )
             
-            benchmark_btn = gr.Button("☁️ Run Cloud Benchmark", variant="primary", size="lg")
+            benchmark_btn = gr.Button("☁️ Run ECHTER Cloud Benchmark", variant="primary", size="lg")
     
-    results_output = gr.Markdown(label="Benchmark Results")
+    results_output = gr.Markdown(label="Echte Benchmark Results")
     
     benchmark_btn.click(
         run_cloud_benchmark,
@@ -192,34 +248,25 @@ with gr.Blocks(title="SAAP Cloud Benchmark", theme=gr.themes.Soft()) as demo:
         outputs=results_output
     )
     
-    with gr.Accordion("🎓 SAAP Thesis: Methodologie & Daten", open=False):
+    with gr.Accordion("🎓 Authentische SAAP Thesis-Daten", open=False):
         gr.Markdown("""
-        ### 📊 Benchmark-Methodologie
-        
-        **🏠 On-Premise Baselines (Echte Messwerte):**
-        - **Hardware:** Intel i7-5600U, 16GB RAM, keine GPU
-        - **qwen2:1.5b:** 25.94s | **tinyllama:** 17.96s
-        - **Durchschnitt:** ~22s für Multi-Agent-Koordinations-Prompts
-        - **Messung:** Direkt auf CachyOS mit Ollama
-        
-        **☁️ Cloud Performance (Simuliert):**
-        - **Basis:** Typische HuggingFace GPU-Cluster Performance
-        - **Models:** Vergleichbare Komplexität zu lokalen Models
-        - **Simulierte Hardware:** A100/V100 GPU-optimierte Inferenz
+        ### ⚡ Echter API vs. Simulation
         
-        ### 🎯 Thesis-Relevante Erkenntnisse:
+        **Vorher:** Simulierte 1.5s (unrealistisch)
+        **Jetzt:** Echte HuggingFace GPU-Cluster Performance
         
-        1. **Performance-Vergleich:** Quantifizierbare Geschwindigkeitsunterschiede
-        2. **Kostenanalyse:** TCO-Berechnung über 3-5 Jahre
-        3. **DSGVO-Compliance:** Rechtliche Anforderungen vs. Performance
-        4. **Verfügbarkeit:** Offline-Betrieb vs. Internet-Abhängigkeit
-        5. **Skalierung:** Lineare Kosten (Cloud) vs. Fixkosten (On-Premise)
+        ### 📊 Erwartete echte Ergebnisse:
+        - **gpt2:** ~3-8s (abhängig von Server-Last)
+        - **distilgpt2:** ~2-5s (kleineres Model)
+        - **DialoGPT:** ~4-10s (Dialog-optimiert)
         
-        ### 🚀 Dual-Benchmark Setup:
-        - **Lokale App:** http://127.0.0.1:7860 (Echte On-Premise Daten)
-        - **Cloud App:** Diese Simulation (Typische Cloud-Performance)
+        ### 🎯 Authentische Thesis-Daten:
+        - ✅ Echte Cloud-Performance-Messwerte
+        - ✅ Vergleichbar mit deinen On-Premise Daten (17-26s)
+        - ✅ Realistische Kostenabschätzung möglich
+        - ✅ Echte API-Latenz und Zuverlässigkeit
         
-        **🎓 Ergebnis:** Fundierte Datengrundlage für SAAP Multi-Agent Platform Entscheidungen
+        **Lokale App:** http://127.0.0.1:7860
         """)
 
 if __name__ == "__main__":