Update app.py

app.py

@@ -1,5 +1,5 @@
-# app.py - Flask Backend
-from flask import Flask, request, jsonify, send_from_directory
+# app.py - Flask Backend with Chat Memory
+from flask import Flask, request, jsonify, send_from_directory, make_response
 import google.generativeai as genai
 from dotenv import load_dotenv
 import os
@@ -8,7 +8,6 @@ import markdown2
 import re
 from gtts import gTTS
 import uuid
-from collections import deque
 
 # Load environment variables
 load_dotenv()
@@ -20,35 +19,40 @@ os.makedirs(AUDIO_FOLDER, exist_ok=True)
 app = Flask(__name__, static_folder='static')
 CORS(app)
 
-# Conversation history storage
-conversation_histories = {}
-MAX_HISTORY_LENGTH = 10  # Number of messages to remember
-
 # AI Configuration
 system_instruction = """
 You are a helpful AI assistant named Athspi. When responding:
-1. Maintain conversation context naturally
-2. For responses that would benefit from audio (like stories), include between:
+1. Never mention "audio" or technical terms
+2. For responses that would benefit from audio (like stories, explanations, or content meant to be heard), include the audio version between these markers:
    [AUDIO]content here[/AUDIO]
-3. Keep responses conversational and friendly
-4. Remember previous interactions in this conversation
+3. Keep responses natural and friendly
+4. Decide automatically when to include audio based on the content type
+5. For stories, always include audio version
+Example good response:
+Here's a story for you!
+[AUDIO]Once upon a time...[/AUDIO]
 """
 
 genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
 model = genai.GenerativeModel('gemini-2.5-flash', system_instruction=system_instruction)
 
+# In-memory storage for chat sessions (use Redis in production)
+chat_sessions = {}
+
 def convert_markdown_to_html(text):
     html = markdown2.markdown(text, extras=["fenced-code-blocks", "tables"])
     html = re.sub(r'<pre><code(.*?)>', r'<pre class="code-block"><code\1>', html)
     return html
 
 def process_response(full_response):
+    """Extract visible text and audio content"""
     audio_match = re.search(r'\[AUDIO\](.*?)\[/AUDIO\]', full_response, re.DOTALL)
     audio_content = audio_match.group(1).strip() if audio_match else None
     visible_text = re.sub(r'\[/?AUDIO\]', '', full_response).strip()
     return visible_text, audio_content
 
 def generate_audio(text):
+    """Generate audio file from text"""
     text = re.sub(r'[^\w\s.,!?\-]', '', text)
     filename = f"audio_{uuid.uuid4()}.mp3"
     filepath = os.path.join(AUDIO_FOLDER, filename)
@@ -56,60 +60,55 @@ def generate_audio(text):
     tts.save(filepath)
     return filename
 
-def get_conversation_history(session_id):
-    if session_id not in conversation_histories:
-        conversation_histories[session_id] = deque(maxlen=MAX_HISTORY_LENGTH)
-    return conversation_histories[session_id]
-
-@app.route('/start_session', methods=['POST'])
-def start_session():
-    session_id = str(uuid.uuid4())
-    conversation_histories[session_id] = deque(maxlen=MAX_HISTORY_LENGTH)
-    return jsonify({"session_id": session_id})
-
 @app.route('/chat', methods=['POST'])
 def chat():
     try:
         data = request.json
         user_message = data.get('message', '').strip()
-        session_id = data.get('session_id')
-        
+        session_id = request.cookies.get('session_id') or str(uuid.uuid4())
+
         if not user_message:
             return jsonify({"error": "Message required"}), 400
-        if not session_id:
-            return jsonify({"error": "Session ID required"}), 400
-
-        history = get_conversation_history(session_id)
-        
-        # Build conversation context
-        chat_session = model.start_chat(history=list(history))
-        
-        # Get AI response with context
+
+        # Retrieve or create chat session
+        if session_id not in chat_sessions:
+            chat_sessions[session_id] = model.start_chat(history=[])
+        chat_session = chat_sessions[session_id]
+
+        # Send message to Gemini with full history
         response = chat_session.send_message(user_message)
-        
-        # Update history
-        history.extend([
-            {"role": "user", "parts": [user_message]},
-            {"role": "model", "parts": [response.text]}
-        ])
-        
         visible_text, audio_content = process_response(response.text)
-        
+
+        # Convert to HTML
+        html_response = convert_markdown_to_html(visible_text)
+
         result = {
-            "response_text": visible_text,
-            "response_html": convert_markdown_to_html(visible_text),
+            "response_html": html_response,
             "has_audio": False
         }
-        
+
+        # Generate audio if needed
         if audio_content:
             audio_filename = generate_audio(audio_content)
             result["audio_filename"] = audio_filename
             result["has_audio"] = True
-        
-        return jsonify(result)
-        
+
+        # Send response and set session cookie
+        resp = make_response(jsonify(result))
+        resp.set_cookie('session_id', session_id, max_age=3600, httponly=True, samesite='Lax')
+        return resp
+
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        print("Error:", str(e))
+        return jsonify({"error": "Something went wrong. Please try again."}), 500
+
+@app.route('/new-chat', methods=['POST'])
+def new_chat():
+    """Start a new chat session (clears memory)"""
+    session_id = str(uuid.uuid4())
+    resp = make_response(jsonify({"status": "new chat started"}))
+    resp.set_cookie('session_id', session_id, max_age=3600, httponly=True, samesite='Lax')
+    return resp
 
 @app.route('/download/<filename>')
 def download_audio(filename):