Update app.py

app.py

@@ -1,120 +1,47 @@
 from flask import Flask, render_template, request, jsonify
+from src.retrieval import retrieve_relevant_documents
+from src.generation import generate_response
+from src.history import save_conversation, load_conversation
 import yaml
-import json
-import logging
-import threading
-from threading import Lock
-import time
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
+import os
+from datetime import datetime
 
 app = Flask(__name__)
 
 # Load configuration
-try:
-    with open("config/config.yaml", "r") as f:
-        config = yaml.safe_load(f)
-except FileNotFoundError as e:
-    logger.error("Configuration file config.yaml not found in config/ directory: %s", e)
-    raise
-
-# Lazy loading setup
-retrieval_system = None
-response_generator = None
-history_manager = None
-init_lock = Lock()
-is_initialized = False
-
-def initialize_components():
-    global retrieval_system, response_generator, history_manager, is_initialized
-    with init_lock:
-        if not is_initialized:
-            try:
-                from src.retrieval import RetrievalSystem
-                from src.generation import ResponseGenerator
-                from src.history import HistoryManager
-
-                # Retry mechanism for model initialization
-                for attempt in range(1, 4):
-                    try:
-                        retrieval_system = RetrievalSystem(config["data"]["document_path"], config["retrieval"]["model"])
-                        response_generator = ResponseGenerator(config["generation"]["model_name"])
-                        history_manager = HistoryManager(config["data"]["history_path"])
-                        break
-                    except Exception as e:
-                        logger.warning("Attempt %d failed to initialize components: %s", attempt, e)
-                        if attempt == 3:
-                            logger.error("Failed to initialize components after 3 attempts: %s", e)
-                            raise
-                        time.sleep(5)  # Wait before retrying
+with open('config/config.yaml', 'r') as f:
+    config = yaml.safe_load(f)
 
-                is_initialized = True
-                logger.info("Successfully initialized RetrievalSystem, ResponseGenerator, and HistoryManager")
-            except Exception as e:
-                logger.error("Initialization error: %s", e)
-                raise
-
-# Start background thread to initialize models
-threading.Thread(target=initialize_components, daemon=True).start()
-
-# Quick replies for Rupeia categories
+# Initialize quick replies
 QUICK_REPLIES = [
-    {"title": "Investments", "value": "Tell me about investments"},
-    {"title": "Goals", "value": "How can I set financial goals?"},
-    {"title": "Benefits", "value": "What are the benefits of Rupeia?"},
-    {"title": "Gadgets", "value": "Help me save for a gadget"},
-    {"title": "News & Blogs", "value": "Show me financial news"}
+    {"title": "Investment options", "value": "investment options"},
+    {"title": "Saving goals", "value": "saving goals"},
+    {"title": "Account benefits", "value": "account benefits"}
 ]
 
 @app.route('/')
-def index():
+def home():
     return render_template('index.html')
 
 @app.route('/api/chat', methods=['POST'])
 def chat():
-    # Ensure components are initialized
-    if not is_initialized:
-        initialize_components()
-
-    try:
-        data = request.get_json()
-        user_input = data.get('message', '').strip()
-        if not user_input:
-            return jsonify({"text": "Please provide a message.", "quickReplies": []}), 400
-
-        logger.info("Received user message: %s", user_input)
-
-        # Load history
-        history = history_manager.load_history()
-
-        # Handle welcome message
-        if user_input.lower() == "hello":
-            response = "Hi there! How can I help you today?"
-            history.append(("hello", response))
-            history_manager.save_history(history)
-            logger.info("Sent welcome message")
-            return jsonify({"text": response, "quickReplies": QUICK_REPLIES})
-
-        # Retrieve context using RAG
-        context = retrieval_system.get_context(user_input)
-        logger.info("Retrieved context: %s", context)
-
-        # Generate response
-        response = response_generator.generate_response(user_input, context, history)
-        logger.info("Generated response: %s", response)
-
-        # Update history
-        history.append((user_input, response))
-        history_manager.save_history(history)
-
-        # Return response with quick replies
-        return jsonify({"text": response, "quickReplies": QUICK_REPLIES})
-
-    except Exception as e:
-        logger.error("Error processing chat request: %s", e)
-        return jsonify({"text": f"Sorry, we're experiencing technical difficulties: {str(e)}", "quickReplies": []}), 500
-
-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=8000, debug=True)
+    user_message = request.json.get('message', '')
+    conversation_id = request.json.get('conversation_id', str(datetime.now().timestamp()))
+    
+    # Retrieve relevant documents
+    context = retrieve_relevant_documents(user_message)
+    
+    # Generate response
+    bot_response = generate_response(user_message, context)
+    
+    # Save conversation
+    save_conversation(conversation_id, user_message, bot_response)
+    
+    return jsonify({
+        'text': bot_response,
+        'quickReplies': QUICK_REPLIES,
+        'conversation_id': conversation_id
+    })
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=8000, debug=True)