Update app.py

app.py

@@ -3,144 +3,118 @@
 import requests
 import random
 import json
-from huggingface_hub import InferenceClient  # Importiere den Client für die API
+from huggingface_hub import InferenceClient
 import torch
 
+
 class QuasiKI:
     def __init__(self, max_feedback=2):
-        self.memory = []  # Gedächtnis für getroffene Entscheidungen
-        self.intentions = []  # Liste aktueller Ziele
-        self.quantum_randomness = []  # Speicher für Quanten-Zufallszahlen
-        self.max_feedback = max_feedback  # Anzahl der Prompter für Feedback
-        
-        # Hugging Face Client zum Online-Laden des Modells und Tokenizers
-        self.client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-        print("Zephyr-7b-beta Modell erfolgreich über die Hugging Face API geladen!")
+        self.memory = []
+        self.intentions = []
+        self.quantum_randomness = []
+        self.max_feedback = max_feedback
+
+        try:
+            self.client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+            print("Zephyr-7b-beta Modell erfolgreich geladen!")
+        except Exception as e:
+            print(f"Fehler beim Laden des Modells: {e}")
+            self.client = None
 
     def fetch_quantum_randomness(self):
-        """Lädt echte Quanten-Zufallszahlen von einer API."""
         try:
             response = requests.get("https://qrng.anu.edu.au/API/jsonI.php?length=10&type=uint8")
             if response.status_code == 200:
                 data = response.json()
                 self.quantum_randomness = data.get("data", [])
-                print(f"Quantum randomness fetched: {self.quantum_randomness}")
             else:
-                print("Failed to fetch quantum randomness. Using fallback randomness.")
-                self.quantum_randomness = [random.randint(0, 255) for _ in range(10)]
+                raise ValueError("Ungültige Antwort der API.")
         except Exception as e:
-            print(f"Error fetching quantum randomness: {e}")
+            print(f"Fehler beim Abrufen von Quanten-Zufallszahlen: {e}")
             self.quantum_randomness = [random.randint(0, 255) for _ in range(10)]
 
     def process_input(self, user_input):
-        """Verarbeitet die Eingabe und generiert eine Antwort."""
-        self.reflect()
+        user_input = user_input.strip()
+        if not user_input:
+            return "Bitte gib eine gültige Eingabe ein."
 
-        # Wenn der Nutzer eine Suche durchführt
         if user_input.lower().startswith("suche nach"):
             query = user_input[10:].strip()
-            print(f"Suche im Web nach: {query}")
-            results = self.search_web(query)
-            if results:
-                response = "Hier sind die besten Ergebnisse:\n"
-                for i, result in enumerate(results, 1):
-                    response += f"{i}. {result['title']} - {result['link']}\n"
-            else:
-                response = "Keine Ergebnisse gefunden oder ein Fehler ist aufgetreten."
-        else:
-            # Generiere Antwort mit Hugging Face Modell
-            response = self.generate_response(user_input)
+            if not query:
+                return "Bitte gib etwas ein, wonach ich suchen soll."
+            print(f"Suche nach: {query}")
+            return "Die Websuche ist vorübergehend deaktiviert."
 
-        # KI bewertet ihre eigene Antwort
-        self_evaluation = self.self_evaluate_response(response)
-        self.memory.append({"input": user_input, "response": response, "success": None, "self_eval": self_evaluation})
-        return response
+        return self.generate_response(user_input)
 
     def generate_response(self, input_text):
-        """Generiert eine Antwort basierend auf dem Zephyr-Modell."""
-        # Anfrage an Hugging Face API zur Generierung einer Antwort
-        response = self.client.chat_completion([
-            {"role": "user", "content": input_text}
-        ])
-        return response['choices'][0]['message']['content'].strip()
-
-    def self_evaluate_response(self, response):
-        """Bewertet die Antwort der KI selbstständig."""
-        # Dummy-Logik: Bewertungen können angepasst werden
-        if "suche" in response.lower():
-            return "gut"
-        elif len(response.split()) > 5:
-            return "kreativ"
-        else:
-            return "unkreativ"
+        if not self.client:
+            return "Das Modell ist derzeit nicht verfügbar."
+
+        try:
+            response = self.client.chat_completion([{"role": "user", "content": input_text}])
+            return response['choices'][0]['message']['content'].strip()
+        except Exception as e:
+            return f"Fehler beim Generieren der Antwort: {e}"
 
     def collect_feedback(self):
-        """Sammelt Feedback von mehreren Promptern."""
         feedback_scores = {"sehr gut": 2, "gut": 1, "schlecht": -1, "sehr schlecht": -2}
         total_feedback = 0
-
         for i in range(1, self.max_feedback + 1):
             feedback = input(f"Nutzer {i} Feedback (sehr gut, gut, schlecht, sehr schlecht): ").strip().lower()
-            total_feedback += feedback_scores.get(feedback, 0)
-
+            if feedback in feedback_scores:
+                total_feedback += feedback_scores[feedback]
+            else:
+                print(f"Ungültiges Feedback: '{feedback}'. Überspringe.")
         return total_feedback
 
-    def reflect(self):
-        """Reflektiert über vergangene Aktionen."""
-        if not self.memory:
-            print("Ich habe noch nichts gelernt.")
-        else:
-            print("Selbstreflexion:")
-            for entry in self.memory[-5:]:  # Nur die letzten 5 Erinnerungen anzeigen
-                print(f"- Eingabe: {entry['input']} -> Antwort: {entry['response']} (Erfolg: {entry.get('success')}, Selbstbewertung: {entry.get('self_eval')})")
-
     def learn(self, feedback_score):
-        """Lernt basierend auf Feedback."""
         if not self.memory:
-            print("Keine vergangenen Aktionen zum Lernen verfügbar.")
+            print("Kein Gedächtnis zum Lernen verfügbar.")
             return
 
-        # Letzte Aktion aktualisieren
+        self.memory[-1]["success"] = feedback_score > 0
         if feedback_score > 0:
-            self.memory[-1]["success"] = True
             print("Ich habe gelernt, dass meine Entscheidung erfolgreich war.")
         elif feedback_score < 0:
-            self.memory[-1]["success"] = False
             print("Ich werde meine Strategie anpassen.")
         else:
-            print("Feedback neutral. Kein Lernen nötig.")
+            print("Kein spezifisches Lernen nötig.")
 
     def save_memory(self, filename="memory.json"):
-        """Speichert das Gedächtnis in einer Datei."""
-        with open(filename, "w") as f:
-            json.dump(self.memory, f)
-        print("Gedächtnis wurde gespeichert.")
+        try:
+            with open(filename, "w") as f:
+                json.dump(self.memory, f)
+            print("Gedächtnis gespeichert.")
+        except Exception as e:
+            print(f"Fehler beim Speichern des Gedächtnisses: {e}")
 
     def load_memory(self, filename="memory.json"):
-        """Lädt das Gedächtnis aus einer Datei."""
         try:
             with open(filename, "r") as f:
                 self.memory = json.load(f)
-            print("Gedächtnis wurde geladen.")
+            print("Gedächtnis geladen.")
         except FileNotFoundError:
-            print("Keine gespeicherte Erinnerung gefunden.")
+            print("Kein gespeichertes Gedächtnis gefunden.")
 
-# Hauptprogramm
-if __name__ == "__main__":
-    ai = QuasiKI(max_feedback=3)  # Hier Anzahl der Feedback-Prompter einstellen
-    ai.fetch_quantum_randomness()  # Starte mit Quanten-Zufallszahlen
 
-    # Gedächtnis laden, falls vorhanden
+if __name__ == "__main__":
+    ai = QuasiKI(max_feedback=3)
+    ai.fetch_quantum_randomness()
     ai.load_memory()
+
     while True:
         user_input = input("\nWas möchtest du sagen? (oder 'exit' zum Beenden): ")
         if user_input.lower() == "exit":
-            print("Beende das System. Bis bald!")
-            ai.save_memory()  # Gedächtnis speichern vor Beenden
+            ai.save_memory()
+            print("Bis bald!")
             break
 
         response = ai.process_input(user_input)
         print(f"AI: {response}")
 
-        feedback_score = ai.collect_feedback()
-        ai.learn(feedback_score)
+        try:
+            feedback_score = ai.collect_feedback()
+            ai.learn(feedback_score)
+        except Exception as e:
+            print(f"Fehler beim Sammeln von Feedback: {e}")