Update app.py

app.py

@@ -20,121 +20,104 @@ logging.basicConfig(
     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!")
-
-# ------------------ Einstellungen für das Memory-Dataset ------------------
-DATASET_REPO = "AiCodeCarft/customer_memory"
-
-def load_memory_dataset():
-    try:
-        ds = load_dataset(DATASET_REPO, split="train")
-        logger.info("Dataset erfolgreich vom HF Hub geladen.")
-    except Exception as e:
-        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)
-        logger.info("Neues Dataset erfolgreich erstellt und gepusht.")
-    return ds
-
-def add_to_memory(user_id, query, response):
-    ds = load_memory_dataset()
-    new_entry = Dataset.from_dict({
-        "user_id": [user_id],
-        "query": [query],
-        "response": [response]
-    })
-    updated_ds = concatenate_datasets([ds, new_entry])
-    updated_ds.push_to_hub(DATASET_REPO)
-    logger.info("Memory-Dataset erfolgreich aktualisiert.")
-
-def get_memory(user_id):
-    ds = load_memory_dataset()
-    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
-
-# ------------------ 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 oben in der Haupt-UI
-openai_api_key = st.text_input("Enter OpenAI API Key", type="password")
-
-if not openai_api_key:
-    st.warning("⚠️ Please enter your OpenAI API key to continue.")
-    st.stop()
+# ------------------ Initialisierung ------------------
+def main():
+    logger.info("App-Initialisierung gestartet...")
+    
+    # ------------------ Hugging Face Token ------------------
+    HF_TOKEN_MEMORY = os.getenv("HF_TOKEN_MEMORY", st.secrets.get("HF_TOKEN_MEMORY", ""))
+    if not HF_TOKEN_MEMORY:
+        st.warning("Hugging Face Token fehlt (für Dataset-Zugriff)")
+    
+    # ------------------ Streamlit UI ------------------
+    st.title("AI Customer Support Agent with Memory 🛒")
+    st.caption("Chat with an assistant who remembers past interactions")
+
+    # OpenAI Key Eingabe
+    openai_api_key = st.text_input("Enter OpenAI API Key", type="password", key="openai_key")
+    if not openai_api_key:
+        st.warning("⚠️ API-Key benötigt")
+        st.stop()
 
-openai.api_key = openai_api_key  # Direktes Setzen des API-Keys
+    openai.api_key = openai_api_key
 
-# ------------------ Klasse: CustomerSupportAIAgent ------------------
-class CustomerSupportAIAgent:
-    def __init__(self):
-        self.client = openai
-        self.app_id = "customer-support"
+    # ------------------ Dataset Funktionen ------------------
+    DATASET_REPO = "AiCodeCarft/customer_memory"
 
-    def handle_query(self, query, user_id=None):
+    @st.cache_resource
+    def load_memory_dataset():
         try:
-            memories = get_memory(user_id)
-            context = "Relevant past information:\n"
-            if len(memories) > 0:
-                for entry in memories:
-                    context += f"- Query: {entry['query']}\n  Response: {entry['response']}\n"
+            return load_dataset(DATASET_REPO, split="train", use_auth_token=HF_TOKEN_MEMORY)
+        except:
+            return Dataset.from_dict({"user_id": [], "query": [], "response": []})
+
+    # ------------------ AI Agent Klasse ------------------
+    class CustomerSupportAIAgent:
+        def __init__(self):
+            self.memory = load_memory_dataset()
+
+        def handle_query(self, query, user_id):
+            # Memory abrufen
+            user_history = self.memory.filter(lambda x: x["user_id"] == user_id)
             
-            full_prompt = f"{context}\nCustomer: {query}\nSupport Agent:"
+            # Kontext erstellen
+            context = "Previous interactions:\n" + "\n".join(
+                [f"Q: {h['query']}\nA: {h['response']}" 
+                 for h in user_history]
+            ) if len(user_history) > 0 else "No previous interactions"
             
-            # API-Key wird direkt übergeben
-            answer = self.client.ChatCompletion.create(
+            # API-Anfrage
+            response = openai.ChatCompletion.create(
                 model="gpt-3.5-turbo",
                 messages=[
-                    {"role": "system", "content": "You are a customer support AI for TechGadgets.com."},
-                    {"role": "user", "content": full_prompt}
+                    {"role": "system", "content": f"You are a support agent. Context:\n{context}"},
+                    {"role": "user", "content": query}
                 ]
-            ).choices[0].message.content
+            )
+            
+            # Antwort verarbeiten
+            answer = response.choices[0].message.content
+            
+            # Memory aktualisieren
+            new_entry = Dataset.from_dict({
+                "user_id": [user_id],
+                "query": [query],
+                "response": [answer]
+            })
+            self.memory = concatenate_datasets([self.memory, new_entry])
+            self.memory.push_to_hub(DATASET_REPO, token=HF_TOKEN_MEMORY)
             
-            add_to_memory(user_id, query, answer)
             return answer
-        except Exception as e:
-            logger.error(f"Fehler bei handle_query: {e}")
-            return "Sorry, I encountered an error. Please try again later."
-
-# ------------------ Initialisierung ------------------
-support_agent = CustomerSupportAIAgent()
 
-# ------------------ Sidebar-Komponenten ------------------
-with st.sidebar:
-    st.title("Customer ID")
-    customer_id = st.text_input("Enter your Customer ID", key="customer_id")
-    
-    if 'customer_id' in st.session_state and st.session_state.customer_id:
-        if st.button("Generate Synthetic Data"):
-            # ... (deine bestehende Synthetic Data Logik)
-
-# ------------------ Chat-History Management ------------------
-if "messages" not in st.session_state:
-    st.session_state.messages = []
+    # ------------------ App-Logik ------------------
+    support_agent = CustomerSupportAIAgent()
 
-# ------------------ Chat-Eingabe ------------------
-if prompt := st.chat_input("How can I assist you today?"):
+    # Customer ID Handling
+    customer_id = st.sidebar.text_input("Customer ID", key="cust_id")
     if not customer_id:
-        st.error("❌ Please enter a customer ID first")
+        st.sidebar.error("Bitte Customer ID eingeben")
         st.stop()
-    
-    st.session_state.messages.append({"role": "user", "content": prompt})
-    
-    with st.spinner("Generating response..."):
-        response = support_agent.handle_query(prompt, customer_id)
-    
-    st.session_state.messages.append({"role": "assistant", "content": response})
 
-# ------------------ Nachrichten anzeigen ------------------
-for message in st.session_state.messages:
-    with st.chat_message(message["role"]):
-        st.markdown(message["content"])
+    # Chat-History
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+
+    # Nachrichten anzeigen
+    for msg in st.session_state.messages:
+        st.chat_message(msg["role"]).write(msg["content"])
+
+    # Eingabe verarbeiten
+    if prompt := st.chat_input("Your question"):
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        st.chat_message("user").write(prompt)
+        
+        with st.spinner("Denke nach..."):
+            response = support_agent.handle_query(prompt, customer_id)
+        
+        st.session_state.messages.append({"role": "assistant", "content": response})
+        st.chat_message("assistant").write(response)
+
+# ------------------ Hauptausführung ------------------
+if __name__ == "__main__":
+    main()