Update app.py

app.py

@@ -1,37 +1,62 @@
+# =============================================================================
+# DON'T STEAL THE FREE CODE OF DEVS! Use it for free an do not touch credits!
+# If you steal this code, in the future you will pay for apps like this!
+# A bit of respect goes a long way – all rights reserved under German law.
+# Copyright Volkan Kücükbudak https://github.com/volkansah
+# Repo URL: https://github.com/AiCodeCraft
+# =============================================================================
 import streamlit as st
 import os
 import json
 import datetime
 import openai
+from datetime import timedelta
+import logging
 from datasets import load_dataset, Dataset, concatenate_datasets
-from huggingface_hub import login
 
-# -- Einstellungen für Hugging Face Dataset Repository --
-# Ersetze "your_username/customer_memory" durch deinen eigenen Repository-Namen!
-DATASET_REPO = "AiCodeCarft/customer_memory"
+# ------------------ Logging konfigurieren ------------------
+logging.basicConfig(
+    level=logging.INFO,  # Log-Level auf INFO setzen
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+logger.info("Starte App mit HF-Dataset Memory...")
+
+# ------------------ Hugging Face Token laden ------------------
+HF_TOKEN_MEMORY = os.getenv('HF_TOKEN_MEMORY', '').strip()
+if HF_TOKEN_MEMORY:
+    logger.info("Hugging Face Token gefunden.")
+else:
+    logger.warning("Kein Hugging Face Token gefunden. Falls benötigt, bitte setzen!")
 
-# Hugging Face Login
-hf_token = st.sidebar.text_input("Enter your Hugging Face Token", type="password")
-if hf_token:
-    login(token=hf_token)
-    st.sidebar.success("Logged in to Hugging Face!")
+# ------------------ Einstellungen für das Memory-Dataset ------------------
+DATASET_REPO = "AiCodeCarft/customer_memory"
 
-# Hilfsfunktion: Versuche, das Dataset vom HF Hub zu laden; falls nicht vorhanden, initialisiere es
 def load_memory_dataset():
+    """
+    Versucht, das Memory-Dataset vom HF Hub zu laden.
+    Falls nicht vorhanden, wird ein leeres Dataset mit den Spalten
+    'user_id', 'query' und 'response' erstellt und gepusht.
+    """
     try:
         ds = load_dataset(DATASET_REPO, split="train")
         st.write("Dataset loaded from HF Hub.")
+        logger.info("Dataset erfolgreich vom HF Hub geladen.")
     except Exception as e:
         st.write("Dataset not found on HF Hub. Creating a new one...")
-        # Leeres Dataset mit den Spalten: user_id, query, response
+        logger.info("Kein Dataset gefunden. Erstelle ein neues Dataset...")
         data = {"user_id": [], "query": [], "response": []}
         ds = Dataset.from_dict(data)
         ds.push_to_hub(DATASET_REPO)
         st.write("New dataset created and pushed to HF Hub.")
+        logger.info("Neues Dataset erfolgreich erstellt und gepusht.")
     return ds
 
-# Hilfsfunktion: Füge einen neuen Eintrag (Memory) hinzu und pushe das aktualisierte Dataset
 def add_to_memory(user_id, query, response):
+    """
+    Fügt einen neuen Eintrag (Query und Antwort) zum Memory-Dataset hinzu
+    und pusht das aktualisierte Dataset an den HF Hub.
+    """
     ds = load_memory_dataset()
     # Neuer Eintrag als kleines Dataset
     new_entry = Dataset.from_dict({
@@ -41,71 +66,162 @@ def add_to_memory(user_id, query, response):
     })
     # Bestehendes Dataset mit dem neuen Eintrag zusammenführen
     updated_ds = concatenate_datasets([ds, new_entry])
-    # Aktualisiere das Dataset auf HF Hub
+    # Push updated dataset to HF Hub
     updated_ds.push_to_hub(DATASET_REPO)
     st.write("Memory updated.")
+    logger.info("Memory-Dataset erfolgreich aktualisiert.")
 
-# Hilfsfunktion: Filtere das Dataset nach einer bestimmten customer_id
 def get_memory(user_id):
+    """
+    Filtert das Memory-Dataset nach der angegebenen Customer ID
+    und gibt alle Einträge (Query und Antwort) zurück.
+    """
     ds = load_memory_dataset()
-    return ds.filter(lambda x: x["user_id"] == user_id)
+    filtered_ds = ds.filter(lambda x: x["user_id"] == user_id)
+    logger.info(f"Memory für User {user_id} abgerufen. {len(filtered_ds)} Einträge gefunden.")
+    return filtered_ds
 
-# OpenAI GPT-4 API-Anbindung
+# ------------------ OpenAI GPT-4 API-Anbindung ------------------
 def generate_response(prompt):
+    """
+    Sendet den Prompt an die OpenAI API und gibt die Antwort zurück.
+    """
     response = openai.ChatCompletion.create(
-        model="gpt-4",
+        model="gpt-3.5-turbo",
         messages=[
             {"role": "system", "content": "You are a customer support AI for TechGadgets.com."},
             {"role": "user", "content": prompt}
         ]
     )
+    logger.info("Antwort von OpenAI erhalten.")
     return response.choices[0].message.content
 
-# Streamlit App UI
+# ------------------ Streamlit App UI ------------------
 st.title("AI Customer Support Agent with Memory 🛒")
 st.caption("Chat with a customer support assistant who remembers your past interactions.")
 
-# OpenAI API Key Eingabe
+# Eingabe des OpenAI API Keys
 openai_api_key = st.text_input("Enter OpenAI API Key", type="password")
 if openai_api_key:
-    os.environ["OPENAI_API_KEY"] = openai_api_key
+    os.environ['OPENAI_API_KEY'] = openai_api_key
     openai.api_key = openai_api_key
+    logger.info("OpenAI API Key gesetzt.")
+
+    # ------------------ Klasse: CustomerSupportAIAgent ------------------
+    class CustomerSupportAIAgent:
+        def __init__(self):
+            # Wir nutzen hier die HF Dataset Funktionen als Memory-Speicher
+            self.client = openai  # OpenAI Client
+            self.app_id = "customer-support"
+
+        def handle_query(self, query, user_id=None):
+            try:
+                # Hole relevante Erinnerungen aus dem HF Dataset
+                memories = get_memory(user_id)
+                context = "Relevant past information:\n"
+                # Falls Einträge vorhanden sind, baue den Kontext
+                if len(memories) > 0:
+                    for entry in memories:
+                        context += f"- Query: {entry['query']}\n  Response: {entry['response']}\n"
+                logger.info("Kontext aus Memory-Dataset erstellt.")
+
+                # Kombiniere Kontext und aktuelle Anfrage
+                full_prompt = f"{context}\nCustomer: {query}\nSupport Agent:"
+                logger.info("Vollständiger Prompt für OpenAI erstellt.")
+
+                # Generiere Antwort mit OpenAI
+                answer = generate_response(full_prompt)
+
+                # Speicher die Interaktion im Memory-Dataset
+                add_to_memory(user_id, query, answer)
+                logger.info("Interaktion im Memory-Dataset gespeichert.")
+
+                return answer
+            except Exception as e:
+                logger.error(f"Fehler bei handle_query: {e}")
+                st.error(f"An error occurred while handling the query: {e}")
+                return "Sorry, I encountered an error. Please try again later."
+
+        def generate_synthetic_data(self, user_id: str) -> dict | None:
+            try:
+                today = datetime.datetime.now()
+                order_date = (today - timedelta(days=10)).strftime("%B %d, %Y")
+                expected_delivery = (today + timedelta(days=2)).strftime("%B %d, %Y")
+
+                # Prompt zur Generierung synthetischer Kundendaten für einen Lieferservice
+                prompt = f"""Generate a detailed customer profile and order history for a DeliverItExpress customer with ID {user_id}. Include:
+                1. Customer name and basic info (age, gender, and contact details)
+                2. A recent order of a gourmet meal (placed on {order_date} and delivered by {expected_delivery})
+                3. Order details including food items, total price, and order number
+                4. Customer's delivery address
+                5. 2-3 previous orders from the past year with different types of cuisines
+                6. 2-3 customer service interactions regarding delivery issues (e.g., late delivery, missing items)
+                7. Any preferences or patterns in their ordering behavior (e.g., favorite cuisines, peak ordering times)
 
-    # Sidebar: Customer ID und Optionen
+                Format the output as a JSON object."""
+                logger.info("Prompt for generating synthetic delivery service data created.")
+
+                response = self.client.ChatCompletion.create(
+                    model="gpt-4",
+                    messages=[
+                        {"role": "system", "content": "You are a data generation AI that creates realistic customer profiles and order histories. Always respond with valid JSON."},
+                        {"role": "user", "content": prompt}
+                    ]
+                )
+                logger.info("Antwort für synthetische Daten von OpenAI erhalten.")
+                customer_data = json.loads(response.choices[0].message.content)
+
+                # Optional: Speichere auch diese Daten im Memory-Dataset
+                for key, value in customer_data.items():
+                    if isinstance(value, list):
+                        for item in value:
+                            add_to_memory(user_id, f"{key} item", json.dumps(item))
+                    else:
+                        add_to_memory(user_id, key, json.dumps(value))
+                logger.info("Synthetische Daten im Memory-Dataset gespeichert.")
+                return customer_data
+            except Exception as e:
+                logger.error(f"Fehler bei generate_synthetic_data: {e}")
+                st.error(f"Failed to generate synthetic data: {e}")
+                return None
+
+    # ------------------ Initialisierung des CustomerSupportAIAgent ------------------
+    support_agent = CustomerSupportAIAgent()
+
+    # ------------------ Sidebar: Customer ID und Optionen ------------------
     st.sidebar.title("Enter your Customer ID:")
-    customer_id = st.sidebar.text_input("Customer ID")
-    
-    # Optional: Synthetic Data generieren (Beispiel-Daten)
+    previous_customer_id = st.session_state.get("previous_customer_id", None)
+    customer_id = st.sidebar.text_input("Enter your Customer ID")
+
+    if customer_id != previous_customer_id:
+        st.session_state.messages = []
+        st.session_state.previous_customer_id = customer_id
+        st.session_state.customer_data = None
+        logger.info("Neue Customer ID erkannt – Chatverlauf und synthetische Daten zurückgesetzt.")
+
+    # Button: Synthetische Daten generieren
     if st.sidebar.button("Generate Synthetic Data"):
         if customer_id:
-            synthetic_data = {
-                "name": "Max Mustermann",
-                "recent_order": {
-                    "product": "High-end Smartphone",
-                    "order_date": (datetime.datetime.now() - datetime.timedelta(days=10)).strftime("%B %d, %Y"),
-                    "delivery_date": (datetime.datetime.now() + datetime.timedelta(days=2)).strftime("%B %d, %Y"),
-                    "order_number": "ORD123456"
-                },
-                "previous_orders": [
-                    {"product": "Laptop", "order_date": "January 12, 2025"},
-                    {"product": "Tablet", "order_date": "March 01, 2025"}
-                ],
-                "customer_service_interactions": [
-                    "Asked about order status",
-                    "Inquired about warranty"
-                ]
-            }
-            st.session_state.customer_data = synthetic_data
-            st.sidebar.success("Synthetic data generated!")
+            with st.spinner("Generating customer data..."):
+                st.session_state.customer_data = support_agent.generate_synthetic_data(customer_id)
+            if st.session_state.customer_data:
+                st.sidebar.success("Synthetic data generated successfully!")
+                logger.info("Synthetische Daten erfolgreich generiert.")
+            else:
+                st.sidebar.error("Failed to generate synthetic data.")
+                logger.error("Fehler beim Generieren synthetischer Daten.")
         else:
             st.sidebar.error("Please enter a customer ID first.")
+            logger.warning("Kein Customer ID eingegeben beim Versuch, synthetische Daten zu generieren.")
 
+    # Button: Customer Profile anzeigen
     if st.sidebar.button("View Customer Profile"):
-        if "customer_data" in st.session_state and st.session_state.customer_data:
+        if st.session_state.customer_data:
             st.sidebar.json(st.session_state.customer_data)
         else:
-            st.sidebar.info("No synthetic data available.")
+            st.sidebar.info("No customer data generated yet. Click 'Generate Synthetic Data' first.")
 
+    # Button: Memory-Info anzeigen
     if st.sidebar.button("View Memory Info"):
         if customer_id:
             memories = get_memory(customer_id)
@@ -115,33 +231,36 @@ if openai_api_key:
         else:
             st.sidebar.error("Please enter a customer ID.")
 
-    # Initialisiere Chatverlauf in session_state
+    # ------------------ Chatverlauf initialisieren und anzeigen ------------------
     if "messages" not in st.session_state:
         st.session_state.messages = []
 
-    # Zeige bisherigen Chatverlauf
+    # Vorherige Nachrichten anzeigen
     for message in st.session_state.messages:
-        st.chat_message(message["role"]).markdown(message["content"])
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
 
-    # Haupt-Chat: Benutzer-Eingabe
+    # ------------------ Haupt-Chat: Benutzereingabe ------------------
     query = st.chat_input("How can I assist you today?")
     if query and customer_id:
-        # Hole bisherigen Memory-Context
-        memories = get_memory(customer_id)
-        context = ""
-        for mem in memories:
-            context += f"Query: {mem['query']}\nResponse: {mem['response']}\n"
-        # Kombiniere Kontext mit aktueller Anfrage
-        full_prompt = context + f"\nCustomer: {query}\nSupport Agent:"
-        with st.spinner("Generating response..."):
-            answer = generate_response(full_prompt)
-        # Aktualisiere den Chatverlauf
+        # Benutzeranfrage zum Chatverlauf hinzufügen
         st.session_state.messages.append({"role": "user", "content": query})
+        with st.chat_message("user"):
+            st.markdown(query)
+        logger.info("Benutzeranfrage hinzugefügt.")
+
+        # Generiere Antwort und zeige sie an
+        with st.spinner("Generating response..."):
+            answer = support_agent.handle_query(query, user_id=customer_id)
         st.session_state.messages.append({"role": "assistant", "content": answer})
-        st.chat_message("assistant").markdown(answer)
-        # Speicher die Interaktion in der Memory (Dataset)
-        add_to_memory(customer_id, query, answer)
+        with st.chat_message("assistant"):
+            st.markdown(answer)
+        logger.info("Antwort des Assistenten hinzugefügt.")
+
     elif query and not customer_id:
         st.error("Please enter a customer ID to start the chat.")
+        logger.warning("Chat gestartet ohne Customer ID.")
+
 else:
     st.warning("Please enter your OpenAI API key to use the customer support agent.")
+    logger.info("Warte auf Eingabe des OpenAI API Keys.")