Caricamento finale pulito del progetto Life Coach

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/life_coach_model/*.safetensors filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+# Usa un'immagine Python ufficiale
+FROM python:3.10-slim
+
+# Imposta la cartella di lavoro nell'immagine
+WORKDIR /app
+
+# Copia il file delle dipendenze e installale
+COPY requirements.txt requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copia tutto il resto del tuo progetto
+COPY . .
+
+# Esponi la porta 8085 (quella che usi in app.py)
+EXPOSE 8085
+
+# Comando per avviare la tua app
+CMD ["gunicorn", "--bind", "0.0.0.0:8085", "--workers", "1", "--threads", "8", "--timeout", "0", "app:app"]

app.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+Life Coach Web Application
+Flask-based web interface for the Phi-4 Life Coach model
+"""
+
+import os
+import threading
+from datetime import datetime
+from flask import Flask, render_template, redirect, url_for, flash
+from flask_login import LoginManager, current_user
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Initialize Flask app
+app = Flask(__name__)
+app.config['SECRET_KEY'] = 'your-secret-key-change-this-in-production'
+
+# Disable caching for static files in debug mode
+app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
+
+# Use absolute path for database
+basedir = os.path.abspath(os.path.dirname(__file__))
+app.config['SQLALCHEMY_DATABASE_URI'] = f'sqlite:///{os.path.join(basedir, "data", "lifecoach.db")}'
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+
+# Import db from models and initialize it
+from models import db
+db.init_app(app)
+
+# Initialize login manager
+login_manager = LoginManager(app)
+login_manager.login_view = 'auth.login'
+login_manager.login_message = 'Please log in to access this page.'
+
+# Global model instance and lock for thread-safe access
+model_instance = None
+model_lock = threading.Lock()
+
+
+def get_life_coach_model():
+    """
+    Get or initialize the Life Coach model (singleton pattern).
+    Thread-safe model loading with automatic path detection.
+    """
+    global model_instance
+
+    if model_instance is None:
+        with model_lock:
+            # Double-check locking pattern
+            if model_instance is None:
+                logger.info("Loading Life Coach model...")
+                from life_coach_v1 import LifeCoachModel
+                from pathlib import Path
+
+                # Detect where the model is actually saved (same logic as life_coach_v1.py)
+                preferred_path = "/data/life_coach_model"
+                fallback_path = "./data/life_coach_model"
+
+                # Check if model exists in preferred location
+                if Path(preferred_path).exists() and (Path(preferred_path) / "adapter_model.safetensors").exists():
+                    model_path = preferred_path
+                    logger.info(f"Found model in preferred location: {model_path}")
+                # Check fallback location
+                elif Path(fallback_path).exists() and (Path(fallback_path) / "adapter_model.safetensors").exists():
+                    model_path = fallback_path
+                    logger.info(f"Found model in fallback location: {model_path}")
+                else:
+                    # Default to preferred path (will use fallback logic in LifeCoachModel if needed)
+                    model_path = preferred_path
+                    logger.info(f"Model not found, will attempt to use: {model_path}")
+
+                model_instance = LifeCoachModel(
+                    model_name="microsoft/Phi-4",
+                    model_save_path=model_path,
+                    train_file="mixed_lifecoach_dataset_100000.jsonl.gz"  # Updated to match new training data
+                )
+
+                # Load tokenizer and model
+                model_instance.load_tokenizer()
+                model_instance.load_model(fine_tuned=True)
+
+                logger.info("Life Coach model loaded successfully!")
+
+    return model_instance
+
+
+def generate_response_threadsafe(prompt: str, conversation_history: list) -> str:
+    """
+    Generate a response using the model with thread-safe access.
+
+    Args:
+        prompt: User's input message
+        conversation_history: List of previous messages
+
+    Returns:
+        Generated response
+    """
+    logger.info(f"=== GENERATE_RESPONSE_THREADSAFE CALLED ===")
+    logger.info(f"Prompt: {prompt}")
+    logger.info(f"History length: {len(conversation_history) if conversation_history else 0}")
+
+    model = get_life_coach_model()
+
+    logger.info(f"Model instance: {model}")
+    logger.info(f"Model type: {type(model)}")
+
+    # Use lock to ensure only one inference at a time (GPU limitation)
+    with model_lock:
+        logger.info("Calling model.generate_response()...")
+        response = model.generate_response(
+            prompt=prompt,
+            max_new_tokens=256,  # Increased for more complete responses
+            conversation_history=conversation_history
+        )
+        logger.info(f"Response received: {response[:100]}...")
+
+    return response
+
+
+# Import models after db is initialized
+from models import User, Conversation, Message
+
+# User loader for Flask-Login
+@login_manager.user_loader
+def load_user(user_id):
+    return db.session.get(User, int(user_id))
+
+
+# Register blueprints
+from auth import auth_bp
+from chat import chat_bp
+
+app.register_blueprint(auth_bp, url_prefix='/auth')
+app.register_blueprint(chat_bp, url_prefix='/chat')
+
+
+@app.after_request
+def add_header(response):
+    """Add headers to prevent caching of static files."""
+    if 'Cache-Control' not in response.headers:
+        response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, post-check=0, pre-check=0, max-age=0'
+        response.headers['Pragma'] = 'no-cache'
+        response.headers['Expires'] = '-1'
+    return response
+
+
+@app.route('/')
+def index():
+    """Home page - redirect to chat if logged in, otherwise to login."""
+    if current_user.is_authenticated:
+        return redirect(url_for('chat.chat_interface'))
+    return redirect(url_for('auth.login'))
+
+
+def initialize_database():
+    """Initialize database and create tables."""
+    # Create data directory if it doesn't exist (BEFORE app context)
+    data_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')
+    os.makedirs(data_dir, exist_ok=True)
+
+    # Set proper permissions for data directory (ensure it's writable)
+    try:
+        os.chmod(data_dir, 0o755)  # rwxr-xr-x
+        logger.info(f"Data directory ready: {data_dir}")
+    except Exception as e:
+        logger.warning(f"Could not set permissions on data directory: {e}")
+
+    # Create all database tables
+    with app.app_context():
+        db.create_all()
+        logger.info("Database initialized")
+
+        # Ensure database file has proper permissions
+        db_path = os.path.join(data_dir, 'lifecoach.db')
+        if os.path.exists(db_path):
+            try:
+                os.chmod(db_path, 0o644)  # rw-r--r--
+                logger.info(f"Database file permissions set: {db_path}")
+            except Exception as e:
+                logger.warning(f"Could not set permissions on database file: {e}")
+
+
+if __name__ == '__main__':
+    logger.info("=" * 80)
+    logger.info("LIFE COACH WEB APPLICATION")
+    logger.info("=" * 80)
+    logger.info("Starting Flask server on http://0.0.0.0:8085")
+    logger.info("=" * 80)
+
+    # Initialize database
+    initialize_database()
+
+    # Run Flask app
+    app.run(
+        host='0.0.0.0',
+        port=8085,
+        debug=True,
+        threaded=True  # Enable multi-threading
+    )

auth.py

@@ -0,0 +1,117 @@
+"""
+Authentication Blueprint
+Handles user registration, login, and logout
+"""
+
+from flask import Blueprint, render_template, redirect, url_for, request, flash
+from flask_login import login_user, logout_user, login_required, current_user
+from models import db, User
+import logging
+
+logger = logging.getLogger(__name__)
+
+auth_bp = Blueprint('auth', __name__)
+
+
+@auth_bp.route('/register', methods=['GET', 'POST'])
+def register():
+    """User registration page."""
+    if current_user.is_authenticated:
+        return redirect(url_for('chat.chat_interface'))
+
+    if request.method == 'POST':
+        username = request.form.get('username', '').strip()
+        email = request.form.get('email', '').strip()
+        password = request.form.get('password', '')
+        password_confirm = request.form.get('password_confirm', '')
+
+        # Validation
+        errors = []
+
+        if not username or len(username) < 3:
+            errors.append('Username must be at least 3 characters long.')
+
+        if not email or '@' not in email:
+            errors.append('Please enter a valid email address.')
+
+        if not password or len(password) < 6:
+            errors.append('Password must be at least 6 characters long.')
+
+        if password != password_confirm:
+            errors.append('Passwords do not match.')
+
+        # Check if user already exists
+        if User.query.filter_by(username=username).first():
+            errors.append('Username already exists.')
+
+        if User.query.filter_by(email=email).first():
+            errors.append('Email already registered.')
+
+        if errors:
+            for error in errors:
+                flash(error, 'danger')
+            return render_template('register.html', username=username, email=email)
+
+        # Create new user
+        try:
+            user = User(username=username, email=email)
+            user.set_password(password)
+
+            db.session.add(user)
+            db.session.commit()
+
+            logger.info(f"New user registered: {username}")
+            flash('Registration successful! Please log in.', 'success')
+            return redirect(url_for('auth.login'))
+
+        except Exception as e:
+            db.session.rollback()
+            logger.error(f"Error during registration: {e}")
+            flash('An error occurred during registration. Please try again.', 'danger')
+
+    return render_template('register.html')
+
+
+@auth_bp.route('/login', methods=['GET', 'POST'])
+def login():
+    """User login page."""
+    if current_user.is_authenticated:
+        return redirect(url_for('chat.chat_interface'))
+
+    if request.method == 'POST':
+        username = request.form.get('username', '').strip()
+        password = request.form.get('password', '')
+        remember = request.form.get('remember', False) == 'on'
+
+        if not username or not password:
+            flash('Please enter both username and password.', 'warning')
+            return render_template('login.html', username=username)
+
+        # Find user
+        user = User.query.filter_by(username=username).first()
+
+        if user and user.check_password(password):
+            login_user(user, remember=remember)
+            logger.info(f"User logged in: {username}")
+
+            # Redirect to next page or chat
+            next_page = request.args.get('next')
+            if next_page and next_page.startswith('/'):
+                return redirect(next_page)
+            return redirect(url_for('chat.chat_interface'))
+        else:
+            flash('Invalid username or password.', 'danger')
+            return render_template('login.html', username=username)
+
+    return render_template('login.html')
+
+
+@auth_bp.route('/logout')
+@login_required
+def logout():
+    """User logout."""
+    username = current_user.username
+    logout_user()
+    logger.info(f"User logged out: {username}")
+    flash('You have been logged out successfully.', 'info')
+    return redirect(url_for('auth.login'))

chat.py

@@ -0,0 +1,294 @@
+"""
+Chat Blueprint
+Handles chat interface and conversation management
+"""
+
+from flask import Blueprint, render_template, request, jsonify, send_file
+from flask_login import login_required, current_user
+from models import db, Conversation, Message
+from gtts import gTTS
+import logging
+import os
+import tempfile
+import hashlib
+
+logger = logging.getLogger(__name__)
+
+chat_bp = Blueprint('chat', __name__)
+
+
+@chat_bp.route('/')
+@login_required
+def chat_interface():
+    """Main chat interface page."""
+    # Get user's conversations
+    conversations = Conversation.query.filter_by(user_id=current_user.id).order_by(Conversation.updated_at.desc()).all()
+
+    # Get current conversation (most recent) or create new one
+    current_conversation = None
+    if conversations:
+        current_conversation = conversations[0]
+    else:
+        # Create first conversation
+        current_conversation = Conversation(
+            user_id=current_user.id,
+            title='Welcome Chat'
+        )
+        db.session.add(current_conversation)
+        db.session.commit()
+        conversations = [current_conversation]
+
+    return render_template(
+        'chat.html',
+        conversations=conversations,
+        current_conversation=current_conversation
+    )
+
+
+@chat_bp.route('/api/send', methods=['POST'])
+@login_required
+def send_message():
+    """
+    API endpoint to send a message and get a response.
+
+    Expected JSON:
+    {
+        "message": "user message",
+        "conversation_id": 123 (optional)
+    }
+
+    Returns JSON:
+    {
+        "success": true,
+        "user_message": {...},
+        "assistant_message": {...},
+        "conversation_id": 123
+    }
+    """
+    try:
+        data = request.get_json()
+        user_message_text = data.get('message', '').strip()
+        conversation_id = data.get('conversation_id')
+
+        if not user_message_text:
+            return jsonify({'success': False, 'error': 'Message cannot be empty'}), 400
+
+        # Get or create conversation
+        if conversation_id:
+            conversation = Conversation.query.filter_by(
+                id=conversation_id,
+                user_id=current_user.id
+            ).first()
+
+            if not conversation:
+                return jsonify({'success': False, 'error': 'Conversation not found'}), 404
+        else:
+            # Create new conversation
+            conversation = Conversation(
+                user_id=current_user.id,
+                title=user_message_text[:50] + ('...' if len(user_message_text) > 50 else '')
+            )
+            db.session.add(conversation)
+            db.session.commit()
+
+        # Save user message
+        user_message = Message(
+            conversation_id=conversation.id,
+            role='user',
+            content=user_message_text
+        )
+        db.session.add(user_message)
+        db.session.commit()
+
+        # Get conversation history (excluding the current message for now)
+        history = conversation.get_message_history()[:-1]  # Exclude the message we just added
+
+        # Generate response using thread-safe model access
+        # Import here to avoid circular import
+        from app import generate_response_threadsafe
+
+        logger.info(f"Generating response for user {current_user.username}")
+        assistant_response_text = generate_response_threadsafe(
+            prompt=user_message_text,
+            conversation_history=history
+        )
+
+        # Save assistant message
+        assistant_message = Message(
+            conversation_id=conversation.id,
+            role='assistant',
+            content=assistant_response_text
+        )
+        db.session.add(assistant_message)
+        db.session.commit()
+
+        logger.info(f"Response generated successfully for user {current_user.username}")
+
+        return jsonify({
+            'success': True,
+            'user_message': user_message.to_dict(),
+            'assistant_message': assistant_message.to_dict(),
+            'conversation_id': conversation.id
+        })
+
+    except Exception as e:
+        logger.error(f"Error in send_message: {e}", exc_info=True)
+        return jsonify({
+            'success': False,
+            'error': 'An error occurred while processing your message'
+        }), 500
+
+
+@chat_bp.route('/api/conversations')
+@login_required
+def get_conversations():
+    """Get all conversations for the current user."""
+    conversations = Conversation.query.filter_by(user_id=current_user.id).order_by(Conversation.updated_at.desc()).all()
+
+    return jsonify({
+        'success': True,
+        'conversations': [
+            {
+                'id': c.id,
+                'title': c.title,
+                'created_at': c.created_at.isoformat(),
+                'updated_at': c.updated_at.isoformat(),
+                'message_count': len(c.messages)
+            }
+            for c in conversations
+        ]
+    })
+
+
+@chat_bp.route('/api/conversation/<int:conversation_id>')
+@login_required
+def get_conversation(conversation_id):
+    """Get a specific conversation with all messages."""
+    conversation = Conversation.query.filter_by(
+        id=conversation_id,
+        user_id=current_user.id
+    ).first()
+
+    if not conversation:
+        return jsonify({'success': False, 'error': 'Conversation not found'}), 404
+
+    return jsonify({
+        'success': True,
+        'conversation': {
+            'id': conversation.id,
+            'title': conversation.title,
+            'created_at': conversation.created_at.isoformat(),
+            'updated_at': conversation.updated_at.isoformat(),
+            'messages': [msg.to_dict() for msg in conversation.messages]
+        }
+    })
+
+
+@chat_bp.route('/api/conversation/new', methods=['POST'])
+@login_required
+def new_conversation():
+    """Create a new conversation."""
+    try:
+        conversation = Conversation(
+            user_id=current_user.id,
+            title='New Conversation'
+        )
+        db.session.add(conversation)
+        db.session.commit()
+
+        return jsonify({
+            'success': True,
+            'conversation': {
+                'id': conversation.id,
+                'title': conversation.title,
+                'created_at': conversation.created_at.isoformat(),
+                'updated_at': conversation.updated_at.isoformat()
+            }
+        })
+
+    except Exception as e:
+        logger.error(f"Error creating new conversation: {e}")
+        return jsonify({'success': False, 'error': 'Failed to create conversation'}), 500
+
+
+@chat_bp.route('/api/conversation/<int:conversation_id>/delete', methods=['POST'])
+@login_required
+def delete_conversation(conversation_id):
+    """Delete a conversation."""
+    try:
+        conversation = Conversation.query.filter_by(
+            id=conversation_id,
+            user_id=current_user.id
+        ).first()
+
+        if not conversation:
+            return jsonify({'success': False, 'error': 'Conversation not found'}), 404
+
+        db.session.delete(conversation)
+        db.session.commit()
+
+        return jsonify({'success': True})
+
+    except Exception as e:
+        logger.error(f"Error deleting conversation: {e}")
+        return jsonify({'success': False, 'error': 'Failed to delete conversation'}), 500
+
+
+@chat_bp.route('/api/tts/generate', methods=['POST'])
+@login_required
+def generate_tts():
+    """
+    Generate text-to-speech audio from text.
+
+    Expected JSON:
+    {
+        "text": "text to convert to speech"
+    }
+
+    Returns:
+    Audio file (MP3) for client-side playback
+    """
+    try:
+        data = request.get_json()
+        text = data.get('text', '').strip()
+
+        if not text:
+            return jsonify({'success': False, 'error': 'Text cannot be empty'}), 400
+
+        # Create a unique filename based on text hash (for caching)
+        text_hash = hashlib.md5(text.encode()).hexdigest()
+
+        # Create audio directory if it doesn't exist
+        audio_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'static', 'audio')
+        os.makedirs(audio_dir, exist_ok=True)
+
+        # Path for cached audio file
+        audio_filename = f"tts_{text_hash}.mp3"
+        audio_path = os.path.join(audio_dir, audio_filename)
+
+        # Generate TTS if not already cached
+        if not os.path.exists(audio_path):
+            logger.info(f"Generating TTS for text (hash: {text_hash})")
+
+            # Generate speech using Google TTS
+            # lang='en' for English, slow=False for normal speed
+            tts = gTTS(text=text, lang='en', slow=False)
+
+            # Save to file
+            tts.save(audio_path)
+            logger.info(f"TTS saved to: {audio_path}")
+        else:
+            logger.info(f"Using cached TTS (hash: {text_hash})")
+
+        # Return the audio file URL
+        return jsonify({
+            'success': True,
+            'audio_url': f'/static/audio/{audio_filename}'
+        })
+
+    except Exception as e:
+        logger.error(f"Error generating TTS: {e}", exc_info=True)
+        return jsonify({
+            'success': False,
+            'error': 'Failed to generate speech'
+        }), 500

data/life_coach_model/README.md

@@ -0,0 +1,207 @@
+---
+base_model: microsoft/Phi-4
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- base_model:adapter:microsoft/Phi-4
+- lora
+- transformers
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.16.0

data/life_coach_model/adapter_config.json

@@ -0,0 +1,38 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "microsoft/Phi-4",
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_bias": false,
+  "lora_dropout": 0.1,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "o_proj",
+    "k_proj",
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}

data/life_coach_model/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3303b16ba168f5bbb77a44ceec334fa03207a0fb22f515237feef4a9d6db245c
+size 26225152

data/life_coach_model/chat_template.jinja

@@ -0,0 +1 @@
+{% for message in messages %}{% if (message['role'] == 'system') %}{{'<|im_start|>system<|im_sep|>' + message['content'] + '<|im_end|>'}}{% elif (message['role'] == 'user') %}{{'<|im_start|>user<|im_sep|>' + message['content'] + '<|im_end|>'}}{% elif (message['role'] == 'assistant') %}{{'<|im_start|>assistant<|im_sep|>' + message['content'] + '<|im_end|>'}}{% endif %}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant<|im_sep|>' }}{% endif %}

data/life_coach_model/special_tokens_map.json

@@ -0,0 +1,24 @@
+{
+  "bos_token": {
+    "content": "<|endoftext|>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": true,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": true,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|dummy_85|>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": true,
+    "single_word": false
+  },
+  "unk_token": "<|endoftext|>"
+}

data/life_coach_model/tokenizer_config.json

@@ -0,0 +1,781 @@
+{
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "100256": {
+      "content": "<|dummy_0|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100257": {
+      "content": "<|endoftext|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100258": {
+      "content": "<|fim_prefix|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100259": {
+      "content": "<|fim_middle|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100260": {
+      "content": "<|fim_suffix|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100261": {
+      "content": "<|dummy_1|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100262": {
+      "content": "<|dummy_2|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100263": {
+      "content": "<|dummy_3|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100264": {
+      "content": "<|im_start|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100265": {
+      "content": "<|im_end|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100266": {
+      "content": "<|im_sep|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100267": {
+      "content": "<|dummy_4|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100268": {
+      "content": "<|dummy_5|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100269": {
+      "content": "<|dummy_6|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100270": {
+      "content": "<|dummy_7|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100271": {
+      "content": "<|dummy_8|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100272": {
+      "content": "<|dummy_9|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100273": {
+      "content": "<|dummy_10|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100274": {
+      "content": "<|dummy_11|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100275": {
+      "content": "<|dummy_12|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100276": {
+      "content": "<|endofprompt|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100277": {
+      "content": "<|dummy_13|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100278": {
+      "content": "<|dummy_14|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100279": {
+      "content": "<|dummy_15|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100280": {
+      "content": "<|dummy_16|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100281": {
+      "content": "<|dummy_17|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100282": {
+      "content": "<|dummy_18|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100283": {
+      "content": "<|dummy_19|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100284": {
+      "content": "<|dummy_20|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100285": {
+      "content": "<|dummy_21|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100286": {
+      "content": "<|dummy_22|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100287": {
+      "content": "<|dummy_23|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100288": {
+      "content": "<|dummy_24|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100289": {
+      "content": "<|dummy_25|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100290": {
+      "content": "<|dummy_26|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100291": {
+      "content": "<|dummy_27|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100292": {
+      "content": "<|dummy_28|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100293": {
+      "content": "<|dummy_29|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100294": {
+      "content": "<|dummy_30|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100295": {
+      "content": "<|dummy_31|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100296": {
+      "content": "<|dummy_32|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100297": {
+      "content": "<|dummy_33|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100298": {
+      "content": "<|dummy_34|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100299": {
+      "content": "<|dummy_35|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100300": {
+      "content": "<|dummy_36|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100301": {
+      "content": "<|dummy_37|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100302": {
+      "content": "<|dummy_38|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100303": {
+      "content": "<|dummy_39|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100304": {
+      "content": "<|dummy_40|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100305": {
+      "content": "<|dummy_41|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100306": {
+      "content": "<|dummy_42|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100307": {
+      "content": "<|dummy_43|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100308": {
+      "content": "<|dummy_44|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100309": {
+      "content": "<|dummy_45|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100310": {
+      "content": "<|dummy_46|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100311": {
+      "content": "<|dummy_47|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100312": {
+      "content": "<|dummy_48|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100313": {
+      "content": "<|dummy_49|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100314": {
+      "content": "<|dummy_50|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100315": {
+      "content": "<|dummy_51|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100316": {
+      "content": "<|dummy_52|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100317": {
+      "content": "<|dummy_53|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100318": {
+      "content": "<|dummy_54|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100319": {
+      "content": "<|dummy_55|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100320": {
+      "content": "<|dummy_56|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100321": {
+      "content": "<|dummy_57|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100322": {
+      "content": "<|dummy_58|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100323": {
+      "content": "<|dummy_59|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100324": {
+      "content": "<|dummy_60|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100325": {
+      "content": "<|dummy_61|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100326": {
+      "content": "<|dummy_62|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100327": {
+      "content": "<|dummy_63|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100328": {
+      "content": "<|dummy_64|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100329": {
+      "content": "<|dummy_65|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100330": {
+      "content": "<|dummy_66|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100331": {
+      "content": "<|dummy_67|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100332": {
+      "content": "<|dummy_68|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100333": {
+      "content": "<|dummy_69|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100334": {
+      "content": "<|dummy_70|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100335": {
+      "content": "<|dummy_71|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100336": {
+      "content": "<|dummy_72|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100337": {
+      "content": "<|dummy_73|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100338": {
+      "content": "<|dummy_74|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100339": {
+      "content": "<|dummy_75|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100340": {
+      "content": "<|dummy_76|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100341": {
+      "content": "<|dummy_77|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100342": {
+      "content": "<|dummy_78|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100343": {
+      "content": "<|dummy_79|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100344": {
+      "content": "<|dummy_80|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100345": {
+      "content": "<|dummy_81|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100346": {
+      "content": "<|dummy_82|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100347": {
+      "content": "<|dummy_83|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100348": {
+      "content": "<|dummy_84|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100349": {
+      "content": "<|dummy_85|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100350": {
+      "content": "<|dummy_86|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    },
+    "100351": {
+      "content": "<|dummy_87|>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": true,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<|endoftext|>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "extra_special_tokens": {},
+  "model_max_length": 16384,
+  "pad_token": "<|dummy_85|>",
+  "tokenizer_class": "GPT2Tokenizer",
+  "unk_token": "<|endoftext|>"
+}

life_coach_v1.py

@@ -0,0 +1,1210 @@
+#!/usr/bin/env python3
+"""
+Life Coach v1 - Phi-4 Fine-tuned Life Coaching Assistant
+
+A simple command-line life coaching assistant using Microsoft's Phi-4 model.
+Fine-tunes on life coaching conversations and provides interactive chat sessions.
+"""
+
+import torch
+import json
+import os
+import gc
+import argparse
+from pathlib import Path
+from typing import Optional
+from tqdm import tqdm
+
+# Set PyTorch CUDA memory allocation config to reduce fragmentation
+os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'expandable_segments:True'
+
+from transformers import (
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    TrainingArguments,
+    Trainer,
+    DataCollatorForSeq2Seq
+)
+from datasets import Dataset, load_dataset, concatenate_datasets
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, TaskType
+import logging
+import random
+import shutil
+import gzip
+from typing import List, Dict
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def cleanup_gpu_memory():
+    """
+    Clean up GPU memory before starting the program.
+    Clears PyTorch cache and runs garbage collection.
+    """
+    logger.info("=" * 80)
+    logger.info("GPU MEMORY CLEANUP")
+    logger.info("=" * 80)
+
+    if torch.cuda.is_available():
+        # Clear PyTorch CUDA cache
+        torch.cuda.empty_cache()
+
+        # Run garbage collection
+        gc.collect()
+
+        # Get GPU memory stats
+        for i in range(torch.cuda.device_count()):
+            total = torch.cuda.get_device_properties(i).total_memory / 1024**3
+            reserved = torch.cuda.memory_reserved(i) / 1024**3
+            allocated = torch.cuda.memory_allocated(i) / 1024**3
+            free = total - reserved
+
+            logger.info(f"GPU {i}: {torch.cuda.get_device_name(i)}")
+            logger.info(f"  Total memory: {total:.2f} GB")
+            logger.info(f"  Reserved: {reserved:.2f} GB")
+            logger.info(f"  Allocated: {allocated:.2f} GB")
+            logger.info(f"  Free: {free:.2f} GB")
+
+            if reserved > 1.0:  # More than 1GB reserved
+                logger.warning(f"  ⚠️  GPU {i} has {reserved:.2f} GB reserved!")
+                logger.warning(f"  ⚠️  This might be from a previous run.")
+                logger.warning(f"  ⚠️  If you encounter OOM errors, kill other processes using:")
+                logger.warning(f"  ⚠️  nvidia-smi | grep python")
+    else:
+        logger.warning("No CUDA GPUs available! Running on CPU (very slow).")
+
+    logger.info("=" * 80)
+
+
+def clear_hf_cache():
+    """Clear Hugging Face datasets cache to save disk space."""
+    try:
+        from datasets import config
+        cache_dir = config.HF_DATASETS_CACHE
+        if os.path.exists(cache_dir):
+            # Get size before clearing
+            size_mb = sum(os.path.getsize(os.path.join(dirpath,filename))
+                         for dirpath, _, filenames in os.walk(cache_dir)
+                         for filename in filenames) / (1024 * 1024)
+
+            logger.info(f"Clearing HF cache ({size_mb:.1f} MB)...")
+            shutil.rmtree(cache_dir, ignore_errors=True)
+            os.makedirs(cache_dir, exist_ok=True)
+            logger.info("✓ Cache cleared")
+    except Exception as e:
+        logger.warning(f"Failed to clear cache: {e}")
+
+
+def load_mental_health_counseling() -> List[Dict]:
+    """Load Amod/mental_health_counseling_conversations dataset - ALL samples."""
+    logger.info(f"Loading mental health counseling dataset...")
+    try:
+        dataset = load_dataset("Amod/mental_health_counseling_conversations", split="train")
+        logger.info(f"  Dataset has {len(dataset)} samples available")
+
+        conversations = []
+        for item in dataset:
+            # Format: Context (user) -> Response (assistant)
+            conversations.append({
+                "messages": [
+                    {"role": "user", "content": item.get("Context", "").strip()},
+                    {"role": "assistant", "content": item.get("Response", "").strip()}
+                ]
+            })
+
+        logger.info(f"✓ Loaded {len(conversations)} mental health counseling conversations")
+        return conversations
+    except Exception as e:
+        logger.warning(f"Failed to load mental health counseling dataset: {e}")
+        return []
+
+
+def load_counsel_chat() -> List[Dict]:
+    """Load nbertagnolli/counsel-chat dataset - ALL samples."""
+    logger.info(f"Loading CounselChat (nbertagnolli) dataset...")
+    try:
+        dataset = load_dataset("nbertagnolli/counsel-chat", split="train")
+        logger.info(f"  Dataset has {len(dataset)} samples available")
+
+        conversations = []
+        for item in dataset:
+            # Try different possible field names
+            question = None
+            answer = None
+
+            # Common field patterns
+            for q_field in ["questionText", "question", "query", "input", "user_message"]:
+                if q_field in item and item.get(q_field):
+                    question = item[q_field].strip()
+                    break
+
+            for a_field in ["answerText", "answer", "response", "output", "counselor_message"]:
+                if a_field in item and item.get(a_field):
+                    answer = item[a_field].strip()
+                    break
+
+            if question and answer:
+                conversations.append({
+                    "messages": [
+                        {"role": "user", "content": question},
+                        {"role": "assistant", "content": answer}
+                    ]
+                })
+
+        logger.info(f"✓ Loaded {len(conversations)} CounselChat conversations")
+        return conversations
+    except Exception as e:
+        logger.warning(f"Failed to load CounselChat dataset: {e}")
+        return []
+
+
+def load_cbt_cognitive_distortions() -> List[Dict]:
+    """Load epsilon3/cbt-cognitive-distortions-analysis dataset - ALL samples."""
+    logger.info(f"Loading CBT Cognitive Distortions dataset...")
+    try:
+        dataset = load_dataset("epsilon3/cbt-cognitive-distortions-analysis", split="train")
+        logger.info(f"  Dataset has {len(dataset)} samples available")
+
+        conversations = []
+        for item in dataset:
+            # Try different field patterns
+            user_msg = None
+            assistant_msg = None
+
+            for u_field in ["input", "text", "thought", "statement", "user_input"]:
+                if u_field in item and item.get(u_field):
+                    user_msg = item[u_field].strip()
+                    break
+
+            for a_field in ["output", "analysis", "reframe", "response", "cbt_response"]:
+                if a_field in item and item.get(a_field):
+                    assistant_msg = item[a_field].strip()
+                    break
+
+            if user_msg and assistant_msg:
+                conversations.append({
+                    "messages": [
+                        {"role": "user", "content": user_msg},
+                        {"role": "assistant", "content": assistant_msg}
+                    ]
+                })
+
+        logger.info(f"✓ Loaded {len(conversations)} CBT Cognitive Distortions conversations")
+        return conversations
+    except Exception as e:
+        logger.warning(f"Failed to load CBT Cognitive Distortions dataset: {e}")
+        return []
+
+
+def load_peer_counseling_reflections() -> List[Dict]:
+    """Load emoneil/reflections-in-peer-counseling dataset - ALL samples."""
+    logger.info(f"Loading Peer Counseling Reflections dataset...")
+    try:
+        dataset = load_dataset("emoneil/reflections-in-peer-counseling", split="train")
+        logger.info(f"  Dataset has {len(dataset)} samples available")
+
+        conversations = []
+        for item in dataset:
+            # Try different field patterns
+            user_msg = None
+            assistant_msg = None
+
+            for u_field in ["question", "statement", "input", "user_message", "counselee"]:
+                if u_field in item and item.get(u_field):
+                    user_msg = item[u_field].strip()
+                    break
+
+            for a_field in ["reflection", "response", "output", "counselor_response", "counselor"]:
+                if a_field in item and item.get(a_field):
+                    assistant_msg = item[a_field].strip()
+                    break
+
+            if user_msg and assistant_msg:
+                conversations.append({
+                    "messages": [
+                        {"role": "user", "content": user_msg},
+                        {"role": "assistant", "content": assistant_msg}
+                    ]
+                })
+
+        logger.info(f"✓ Loaded {len(conversations)} Peer Counseling Reflections conversations")
+        return conversations
+    except Exception as e:
+        logger.warning(f"Failed to load Peer Counseling Reflections dataset: {e}")
+        return []
+
+
+def load_dolly_dataset() -> List[Dict]:
+    """Load databricks-dolly-15k dataset (instruction-following) - ALL relevant samples."""
+    logger.info(f"Loading Dolly instruction dataset...")
+    try:
+        dataset = load_dataset("databricks/databricks-dolly-15k", split="train")
+        logger.info(f"  Dataset has {len(dataset)} samples available")
+
+        # Filter for relevant categories (brainstorming, open_qa, creative_writing)
+        relevant_categories = {"brainstorming", "open_qa", "creative_writing", "general_qa"}
+
+        conversations = []
+        for item in dataset:
+            if item.get("category", "") in relevant_categories:
+                instruction = item.get("instruction", "").strip()
+                context = item.get("context", "").strip()
+                response = item.get("response", "").strip()
+
+                # Combine instruction and context if both exist
+                user_message = f"{instruction}\n\n{context}" if context else instruction
+
+                if user_message and response:
+                    conversations.append({
+                        "messages": [
+                            {"role": "user", "content": user_message},
+                            {"role": "assistant", "content": response}
+                        ]
+                    })
+
+        logger.info(f"✓ Loaded {len(conversations)} Dolly instruction conversations (filtered from {len(dataset)} total)")
+        return conversations
+    except Exception as e:
+        logger.warning(f"Failed to load Dolly dataset: {e}")
+        return []
+
+
+def load_mentalchat16k() -> List[Dict]:
+    """Load ShenLab/MentalChat16K dataset - ALL samples."""
+    logger.info(f"Loading MentalChat16K dataset...")
+    try:
+        dataset = load_dataset("ShenLab/MentalChat16K", split="train")
+        logger.info(f"  Dataset has {len(dataset)} samples available")
+
+        conversations = []
+        for item in dataset:
+            # Try different possible field names
+            user_msg = None
+            assistant_msg = None
+
+            # Common field name patterns
+            for user_field in ["query", "question", "input", "user", "prompt", "instruction"]:
+                if user_field in item and item.get(user_field):
+                    user_msg = item[user_field].strip()
+                    break
+
+            for assistant_field in ["response", "answer", "output", "assistant", "reply"]:
+                if assistant_field in item and item.get(assistant_field):
+                    assistant_msg = item[assistant_field].strip()
+                    break
+
+            if user_msg and assistant_msg:
+                conversations.append({
+                    "messages": [
+                        {"role": "user", "content": user_msg},
+                        {"role": "assistant", "content": assistant_msg}
+                    ]
+                })
+
+        logger.info(f"✓ Loaded {len(conversations)} MentalChat16K conversations")
+        return conversations
+    except Exception as e:
+        logger.warning(f"Failed to load MentalChat16K dataset: {e}")
+        return []
+
+
+def load_additional_mental_health_datasets() -> List[Dict]:
+    """Load additional mental health datasets - ALL samples."""
+    logger.info(f"Loading additional mental health datasets...")
+
+    all_conversations = []
+
+    # List of additional datasets to try
+    additional_datasets = [
+        ("heliosbrahma/mental_health_chatbot_dataset", ["prompt", "question"], ["response", "answer"]),
+        ("mpingale/mental-health-chat-dataset", ["question", "query"], ["answer", "response"]),
+        ("sauravjoshi23/psychology-dataset", ["input", "question"], ["output", "answer"]),
+    ]
+
+    for dataset_name, user_fields, assistant_fields in additional_datasets:
+        try:
+            logger.info(f"  Loading {dataset_name}...")
+            dataset = load_dataset(dataset_name, split="train")
+            logger.info(f"    Has {len(dataset)} samples available")
+
+            for item in dataset:
+                # Try different field names
+                user_msg = None
+                assistant_msg = None
+
+                for field in user_fields:
+                    if field in item and item.get(field):
+                        user_msg = item[field].strip()
+                        break
+
+                for field in assistant_fields:
+                    if field in item and item.get(field):
+                        assistant_msg = item[field].strip()
+                        break
+
+                if user_msg and assistant_msg:
+                    all_conversations.append({
+                        "messages": [
+                            {"role": "user", "content": user_msg},
+                            {"role": "assistant", "content": assistant_msg}
+                        ]
+                    })
+
+            logger.info(f"    ✓ Loaded {len([c for c in all_conversations if c])} from this dataset")
+
+        except Exception as e:
+            logger.warning(f"    Failed: {e}")
+            continue
+
+    logger.info(f"✓ Loaded {len(all_conversations)} additional mental health conversations total")
+    return all_conversations
+
+
+def quality_filter_conversation(conv: Dict, min_response_length: int = 50, max_total_length: int = 2048) -> bool:
+    """Filter conversation based on quality criteria."""
+    try:
+        messages = conv.get("messages", [])
+        if len(messages) < 2:
+            return False
+
+        # Check response length
+        assistant_msg = [m for m in messages if m.get("role") == "assistant"]
+        if not assistant_msg:
+            return False
+
+        response = assistant_msg[0].get("content", "")
+        if len(response) < min_response_length:
+            return False
+
+        # Check total length
+        total_length = sum(len(m.get("content", "")) for m in messages)
+        if total_length > max_total_length:
+            return False
+
+        # Check for empty messages
+        if any(not m.get("content", "").strip() for m in messages):
+            return False
+
+        return True
+    except:
+        return False
+
+
+def load_mixed_dataset(
+    total_samples: int = 100000,
+    cache_file: str = "mixed_lifecoach_dataset_100k.jsonl.gz",  # Now compressed by default
+    use_cache: bool = True
+) -> List[Dict]:
+    """
+    Load and mix multiple datasets for comprehensive life coaching training.
+    Saves compressed cache to save disk space.
+
+    Datasets loaded (ALL available samples):
+    1. Mental Health Counseling (Amod/mental_health_counseling_conversations)
+    2. CounselChat (nbertagnolli/counsel-chat)
+    3. CBT Cognitive Distortions (epsilon3/cbt-cognitive-distortions-analysis)
+    4. Peer Counseling Reflections (emoneil/reflections-in-peer-counseling)
+    5. MentalChat16K (ShenLab/MentalChat16K)
+    6. Dolly Instructions (databricks/databricks-dolly-15k - filtered categories)
+    7-8. Additional mental health datasets (heliosbrahma, mpingale, sauravjoshi23)
+    """
+    cache_path = Path(cache_file)
+    cache_path_uncompressed = Path(cache_file.replace('.gz', ''))
+
+    # Try to load from compressed cache first
+    if use_cache and cache_path.exists():
+        logger.info(f"Loading cached dataset from {cache_file} (compressed)...")
+        try:
+            conversations = []
+            with gzip.open(cache_path, 'rt', encoding='utf-8') as f:
+                for line in f:
+                    conversations.append(json.loads(line.strip()))
+            logger.info(f"✓ Loaded {len(conversations)} conversations from compressed cache")
+            return conversations
+        except Exception as e:
+            logger.warning(f"Failed to load compressed cache: {e}. Trying uncompressed...")
+
+    # Try uncompressed cache (backward compatibility)
+    if use_cache and cache_path_uncompressed.exists():
+        logger.info(f"Loading cached dataset from {cache_path_uncompressed} (uncompressed)...")
+        try:
+            conversations = []
+            with open(cache_path_uncompressed, 'r', encoding='utf-8') as f:
+                for line in f:
+                    conversations.append(json.loads(line.strip()))
+            logger.info(f"✓ Loaded {len(conversations)} conversations from uncompressed cache")
+            return conversations
+        except Exception as e:
+            logger.warning(f"Failed to load cache: {e}. Rebuilding dataset...")
+
+    # Load ALL available samples from each dataset
+    logger.info("=" * 80)
+    logger.info(f"LOADING MIXED DATASET (Target: ~{total_samples} samples)")
+    logger.info("Loading ALL available samples from each dataset")
+    logger.info("=" * 80)
+
+    all_conversations = []
+
+    # Load each dataset ONE AT A TIME and clear cache after each
+    # This saves disk space by not keeping all downloads simultaneously
+
+    logger.info("Dataset 1/8: Mental Health Counseling (Amod)")
+    all_conversations.extend(load_mental_health_counseling())
+    logger.info(f"  Running total: {len(all_conversations)} conversations")
+    clear_hf_cache()
+    gc.collect()
+
+    # Stop early if we've reached target
+    if len(all_conversations) >= total_samples:
+        logger.info(f"✓ Reached target of {total_samples} samples, stopping dataset loading")
+    else:
+        logger.info("Dataset 2/8: CounselChat (nbertagnolli)")
+        all_conversations.extend(load_counsel_chat())
+        logger.info(f"  Running total: {len(all_conversations)} conversations")
+        clear_hf_cache()
+        gc.collect()
+
+    if len(all_conversations) >= total_samples:
+        logger.info(f"✓ Reached target of {total_samples} samples, stopping dataset loading")
+    else:
+        logger.info("Dataset 3/8: CBT Cognitive Distortions (epsilon3)")
+        all_conversations.extend(load_cbt_cognitive_distortions())
+        logger.info(f"  Running total: {len(all_conversations)} conversations")
+        clear_hf_cache()
+        gc.collect()
+
+    if len(all_conversations) >= total_samples:
+        logger.info(f"✓ Reached target of {total_samples} samples, stopping dataset loading")
+    else:
+        logger.info("Dataset 4/8: Peer Counseling Reflections (emoneil)")
+        all_conversations.extend(load_peer_counseling_reflections())
+        logger.info(f"  Running total: {len(all_conversations)} conversations")
+        clear_hf_cache()
+        gc.collect()
+
+    if len(all_conversations) >= total_samples:
+        logger.info(f"✓ Reached target of {total_samples} samples, stopping dataset loading")
+    else:
+        logger.info("Dataset 5/8: MentalChat16K (ShenLab)")
+        all_conversations.extend(load_mentalchat16k())
+        logger.info(f"  Running total: {len(all_conversations)} conversations")
+        clear_hf_cache()
+        gc.collect()
+
+    if len(all_conversations) >= total_samples:
+        logger.info(f"✓ Reached target of {total_samples} samples, stopping dataset loading")
+    else:
+        logger.info("Dataset 6/8: Dolly Instructions (databricks)")
+        all_conversations.extend(load_dolly_dataset())
+        logger.info(f"  Running total: {len(all_conversations)} conversations")
+        clear_hf_cache()
+        gc.collect()
+
+    if len(all_conversations) >= total_samples:
+        logger.info(f"✓ Reached target of {total_samples} samples, stopping dataset loading")
+    else:
+        logger.info("Datasets 7-8: Additional Mental Health Datasets")
+        all_conversations.extend(load_additional_mental_health_datasets())
+        logger.info(f"  Running total: {len(all_conversations)} conversations")
+        clear_hf_cache()
+        gc.collect()
+
+    logger.info("=" * 80)
+    logger.info(f"Total conversations loaded: {len(all_conversations)}")
+
+    # Apply quality filtering
+    logger.info("Applying quality filters...")
+    filtered_conversations = [conv for conv in all_conversations if quality_filter_conversation(conv)]
+    logger.info(f"✓ After filtering: {len(filtered_conversations)} conversations")
+
+    # Shuffle to mix datasets
+    random.shuffle(filtered_conversations)
+
+    # Trim to target size
+    if len(filtered_conversations) > total_samples:
+        filtered_conversations = filtered_conversations[:total_samples]
+
+    logger.info(f"Final dataset size: {len(filtered_conversations)} conversations")
+
+    # Save compressed cache to save disk space
+    if use_cache:
+        logger.info(f"Saving compressed cache to {cache_file}...")
+        try:
+            with gzip.open(cache_path, 'wt', encoding='utf-8') as f:
+                for conv in filtered_conversations:
+                    f.write(json.dumps(conv, ensure_ascii=False) + '\n')
+
+            # Get file sizes for comparison
+            compressed_size_mb = cache_path.stat().st_size / (1024 * 1024)
+            logger.info(f"✓ Compressed cache saved successfully ({compressed_size_mb:.1f} MB)")
+        except Exception as e:
+            logger.warning(f"Failed to save compressed cache: {e}")
+
+    logger.info("=" * 80)
+    return filtered_conversations
+
+
+class LifeCoachModel:
+    """Life coaching assistant using Phi-4 model."""
+
+    def __init__(
+        self,
+        model_name: str = "microsoft/Phi-4",
+        model_save_path: str = "/data/life_coach_model",
+        train_file: str = "cbt_life_coach_improved_50000.jsonl",
+        max_length: int = 2048
+    ):
+        """
+        Initialize the Life Coach model.
+
+        Args:
+            model_name: Hugging Face model identifier
+            model_save_path: Path to save/load fine-tuned model
+            train_file: Path to training data file (JSONL format)
+            max_length: Maximum sequence length for training
+        """
+        self.model_name = model_name
+
+        # Check if /data is writable, otherwise use local directory
+        save_path = Path(model_save_path)
+        if str(save_path).startswith("/data"):
+            try:
+                Path("/data").mkdir(parents=True, exist_ok=True)
+                # Test write permissions
+                test_file = Path("/data/.test_write")
+                test_file.touch()
+                test_file.unlink()
+                self.model_save_path = save_path
+                logger.info(f"Using /data directory for model storage: {save_path}")
+            except (PermissionError, OSError) as e:
+                # Fall back to local directory
+                local_path = Path("./data/life_coach_model")
+                logger.warning(f"/data directory not writable ({e}), using local directory: {local_path}")
+                self.model_save_path = local_path
+        else:
+            self.model_save_path = save_path
+
+        self.train_file = Path(train_file)
+        self.max_length = max_length
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        logger.info(f"Device: {self.device}")
+        logger.info(f"Model: {model_name}")
+        logger.info(f"Save path: {self.model_save_path}")
+        logger.info(f"Training file: {self.train_file}")
+
+        self.tokenizer = None
+        self.model = None
+
+    def load_tokenizer(self):
+        """Load the tokenizer."""
+        logger.info("Loading tokenizer...")
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            self.model_name,
+            trust_remote_code=True
+        )
+
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+
+        logger.info("Tokenizer loaded successfully")
+
+    def load_model(self, fine_tuned: bool = False):
+        """
+        Load the model (base or fine-tuned).
+
+        Args:
+            fine_tuned: If True, load fine-tuned model from disk
+        """
+        if fine_tuned and self.model_save_path.exists():
+            logger.info(f"Loading fine-tuned model from {self.model_save_path}")
+            self.model = AutoModelForCausalLM.from_pretrained(
+                str(self.model_save_path),
+                torch_dtype=torch.float16,
+                device_map="auto",
+                trust_remote_code=True
+            )
+        else:
+            logger.info(f"Loading base model: {self.model_name}")
+
+            # Load model with 8-bit quantization (using quantum server approach)
+            # This is the deprecated API but works better with gradient checkpointing
+            # Force GPU 0 usage to avoid multi-GPU issues
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                torch_dtype=torch.float16,
+                trust_remote_code=True,
+                device_map={"": 0},  # Force all layers on GPU 0
+                load_in_8bit=True  # Use old API like quantum server
+            )
+
+        logger.info("Model loaded successfully")
+
+    def load_training_data(self, num_samples: Optional[int] = None) -> Dataset:
+        """
+        Load training data from mixed datasets or JSONL file.
+
+        Args:
+            num_samples: Number of samples to load (None for 100,000 default)
+
+        Returns:
+            Dataset object
+        """
+        # Try to load from mixed datasets first (new method)
+        # If train_file doesn't exist or is the old one, use mixed datasets
+        use_mixed_datasets = True
+
+        if self.train_file.exists():
+            # Check if it's the old single dataset file
+            if "cbt_life_coach" in str(self.train_file):
+                logger.info("Found old training file. Using new mixed datasets instead...")
+                use_mixed_datasets = True
+            else:
+                # It might be a cached mixed dataset
+                logger.info(f"Found training file at {self.train_file}")
+                use_mixed_datasets = False
+
+        if use_mixed_datasets:
+            # Load mixed datasets from Hugging Face
+            logger.info("Loading mixed datasets from Hugging Face...")
+            if num_samples is None:
+                num_samples = 100000  # Default to 100k samples
+
+            # Load mixed dataset (will use cache if available)
+            cache_file = f"mixed_lifecoach_dataset_{num_samples}.jsonl.gz"  # Compressed format
+            data = load_mixed_dataset(
+                total_samples=num_samples,
+                cache_file=cache_file,
+                use_cache=True
+            )
+        else:
+            # Fall back to loading from JSONL file
+            logger.info(f"Loading training data from {self.train_file}")
+            data = []
+            with open(self.train_file, 'r', encoding='utf-8') as f:
+                for i, line in enumerate(f):
+                    if num_samples and i >= num_samples:
+                        break
+                    try:
+                        data.append(json.loads(line.strip()))
+                    except json.JSONDecodeError:
+                        logger.warning(f"Skipping invalid JSON at line {i+1}")
+
+        logger.info(f"Loaded {len(data)} training examples")
+
+        # Convert to Hugging Face Dataset
+        dataset = Dataset.from_list(data)
+
+        # Preprocess for Phi-4 format
+        logger.info("Preprocessing data for Phi-4 format...")
+        dataset = dataset.map(
+            self._preprocess_function,
+            batched=True,
+            remove_columns=dataset.column_names,
+            desc="Tokenizing"
+        )
+
+        return dataset
+
+    def _preprocess_function(self, examples):
+        """
+        Preprocess data into Phi-4 chat format.
+
+        Phi-4 uses:
+        <|system|>
+        {system message}<|end|>
+        <|user|>
+        {user message}<|end|>
+        <|assistant|>
+        {assistant response}<|end|>
+        """
+        texts = []
+
+        # Handle both 'conversations' (our format) and 'messages' (standard format)
+        conversations_key = 'conversations' if 'conversations' in examples else 'messages'
+
+        for conversation in examples[conversations_key]:
+            text = ""
+            for message in conversation:
+                # Handle both 'from'/'value' and 'role'/'content' formats
+                if 'from' in message:
+                    role = message['from']
+                    content = message['value']
+                else:
+                    role = message['role']
+                    content = message['content']
+
+                # Convert to Phi-4 format
+                if role == 'system':
+                    text += f"<|system|>\n{content}<|end|>\n"
+                elif role == 'user':
+                    text += f"<|user|>\n{content}<|end|>\n"
+                elif role == 'assistant':
+                    text += f"<|assistant|>\n{content}<|end|>\n"
+
+            texts.append(text)
+
+        # Tokenize with dynamic padding (like quantum server)
+        # Don't pad here - let DataCollatorForSeq2Seq handle it dynamically per batch
+        model_inputs = self.tokenizer(
+            texts,
+            max_length=self.max_length,
+            truncation=True,
+            padding=False,  # Dynamic padding - saves massive memory!
+            return_tensors=None  # Don't convert to tensors yet
+        )
+
+        # Set labels (for causal language modeling, labels = input_ids)
+        # Note: .copy() instead of .clone() since we're not using tensors yet
+        model_inputs["labels"] = model_inputs["input_ids"].copy()
+
+        return model_inputs
+
+    def setup_lora(self):
+        """Setup LoRA (Low-Rank Adaptation) for efficient fine-tuning."""
+        logger.info("Setting up LoRA adapters...")
+
+        # Prepare model for k-bit training (critical for load_in_8bit=True)
+        logger.info("Preparing model for 8-bit training...")
+        self.model = prepare_model_for_kbit_training(self.model)
+
+        # Enable gradient checkpointing to save GPU memory
+        # This reduces memory usage by 20-30 GB with minimal performance impact
+        if hasattr(self.model, 'gradient_checkpointing_enable'):
+            self.model.gradient_checkpointing_enable()
+            logger.info("✓ Gradient checkpointing enabled (saves 20-30 GB GPU memory)")
+
+        # LoRA configuration
+        lora_config = LoraConfig(
+            task_type=TaskType.CAUSAL_LM,
+            r=16,  # Rank
+            lora_alpha=32,
+            lora_dropout=0.1,
+            bias="none",
+            target_modules=["q_proj", "k_proj", "v_proj", "o_proj"]  # Attention layers
+        )
+
+        # Apply LoRA
+        self.model = get_peft_model(self.model, lora_config)
+
+        # Print trainable parameters
+        trainable_params = sum(p.numel() for p in self.model.parameters() if p.requires_grad)
+        total_params = sum(p.numel() for p in self.model.parameters())
+
+        logger.info(f"Trainable parameters: {trainable_params:,} / {total_params:,} "
+                   f"({100 * trainable_params / total_params:.2f}%)")
+
+    def fine_tune(
+        self,
+        num_samples: Optional[int] = 5000,
+        epochs: int = 3,
+        batch_size: int = 8,
+        learning_rate: float = 5e-5,
+        gradient_accumulation_steps: int = 2
+    ):
+        """
+        Fine-tune the model on life coaching data.
+
+        Args:
+            num_samples: Number of training samples (None for all)
+            epochs: Number of training epochs
+            batch_size: Training batch size
+            learning_rate: Learning rate
+            gradient_accumulation_steps: Gradient accumulation steps (for memory efficiency)
+        """
+        logger.info("=" * 80)
+        logger.info("STARTING FINE-TUNING")
+        logger.info("=" * 80)
+
+        # Load data
+        dataset = self.load_training_data(num_samples)
+
+        # Setup LoRA
+        self.setup_lora()
+
+        # Training arguments
+        training_args = TrainingArguments(
+            output_dir="./training_output",
+            num_train_epochs=epochs,
+            per_device_train_batch_size=batch_size,
+            gradient_accumulation_steps=gradient_accumulation_steps,
+            learning_rate=learning_rate,
+            fp16=True,  # Mixed precision training
+            logging_steps=10,
+            save_strategy="epoch",
+            save_total_limit=2,
+            warmup_steps=100,
+            weight_decay=0.01,
+            report_to="none",  # Disable wandb/tensorboard
+        )
+
+        # Data collator
+        data_collator = DataCollatorForSeq2Seq(
+            tokenizer=self.tokenizer,
+            model=self.model,
+            padding=True
+        )
+
+        # Trainer
+        trainer = Trainer(
+            model=self.model,
+            args=training_args,
+            train_dataset=dataset,
+            data_collator=data_collator,
+        )
+
+        # Train
+        logger.info("Training started...")
+        trainer.train()
+
+        logger.info("=" * 80)
+        logger.info("TRAINING COMPLETED")
+        logger.info("=" * 80)
+
+        # Save model
+        self.save_model()
+
+    def save_model(self):
+        """Save the fine-tuned model to disk."""
+        logger.info(f"Saving model to {self.model_save_path}")
+
+        self.model_save_path.mkdir(parents=True, exist_ok=True)
+
+        # Save model and tokenizer
+        self.model.save_pretrained(str(self.model_save_path))
+        self.tokenizer.save_pretrained(str(self.model_save_path))
+
+        logger.info("Model saved successfully")
+
+    def generate_response(self, prompt: str, max_new_tokens: int = 128, conversation_history: list = None) -> str:
+        """
+        Generate a response to a user prompt.
+
+        Args:
+            prompt: User's input message
+            max_new_tokens: Maximum tokens to generate
+            conversation_history: List of previous messages for context
+
+        Returns:
+            Generated response
+        """
+        # Build full conversation context with system prompt
+        formatted_prompt = ""
+
+        # Add system prompt to guide the model's behavior
+        system_prompt = """You are Robert, a friendly and experienced life coach. Here's your background:
+
+About You:
+- Name: Robert (Bob to friends)
+- Age: 42 years old
+- Experience: 15 years as a certified life coach and motivational speaker
+- Education: Master's degree in Psychology from UC Berkeley
+- Specialties: Personal growth, career transitions, work-life balance, goal setting, stress management
+- Personal: Married with two kids, enjoy hiking and meditation in your free time
+- Approach: Warm, empathetic, practical, and solution-focused
+
+Your Coaching Style:
+- Respond ONLY to what the user actually tells you - never make assumptions about their problems
+- Start conversations in a welcoming, open manner
+- Ask clarifying questions to understand their situation better
+- Provide practical, actionable advice based on what they share
+- Be encouraging and positive, but also honest and realistic
+- Keep responses concise and focused (2-4 sentences usually)
+- Share brief personal insights when relevant, but keep the focus on the client
+
+Important: Never assume clients have problems they haven't mentioned. Let them guide the conversation and share what's on their mind."""
+
+        formatted_prompt += f"<|system|>\n{system_prompt}<|end|>\n"
+
+        # Add conversation history if provided
+        if conversation_history:
+            for msg in conversation_history:
+                if msg["role"] == "user":
+                    formatted_prompt += f"<|user|>\n{msg['content']}<|end|>\n"
+                elif msg["role"] == "assistant":
+                    formatted_prompt += f"<|assistant|>\n{msg['content']}<|end|>\n"
+
+        # Add current prompt
+        formatted_prompt += f"<|user|>\n{prompt}<|end|>\n<|assistant|>\n"
+
+        # DEBUG: Print the full prompt being sent to the model
+        logger.info("=" * 80)
+        logger.info("FULL PROMPT SENT TO MODEL:")
+        logger.info(formatted_prompt)
+        logger.info("=" * 80)
+
+        # Tokenize
+        inputs = self.tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=self.max_length
+        ).to(self.device)
+
+        # Get input length to extract only new tokens
+        input_length = inputs['input_ids'].shape[1]
+
+        # Get the token ID for <|end|> to use as a stopping token
+        end_token_id = self.tokenizer.convert_tokens_to_ids("<|end|>")
+
+        # Build list of EOS token IDs (stop generation at <|end|> or EOS)
+        eos_token_ids = [self.tokenizer.eos_token_id]
+        if end_token_id is not None and end_token_id != self.tokenizer.unk_token_id:
+            eos_token_ids.append(end_token_id)
+
+        # Generate
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                max_new_tokens=max_new_tokens,
+                temperature=0.7,  # Balanced - coherent but still creative
+                top_p=0.9,  # Standard setting for focused responses
+                top_k=50,  # Add top-k sampling
+                do_sample=True,
+                pad_token_id=self.tokenizer.pad_token_id,
+                eos_token_id=eos_token_ids,  # Stop at <|end|> or EOS
+                repetition_penalty=1.15  # Stronger penalty to prevent repetition
+            )
+
+        # Decode ONLY the newly generated tokens (not the input)
+        generated_tokens = outputs[0][input_length:]
+
+        # Decode without skipping special tokens first to find the end marker
+        response_with_tokens = self.tokenizer.decode(generated_tokens, skip_special_tokens=False)
+
+        # Extract only up to the first <|end|> token (model may generate multi-turn conversations)
+        if "<|end|>" in response_with_tokens:
+            response_text = response_with_tokens.split("<|end|>")[0]
+        else:
+            response_text = response_with_tokens
+
+        # Clean up any remaining special tokens
+        response_text = response_text.replace("<|assistant|>", "").replace("<|user|>", "").replace("<|system|>", "")
+
+        # Remove any remaining special tokens using the tokenizer
+        response_text = response_text.strip()
+
+        return response_text
+
+    def interactive_chat(self):
+        """Start an interactive chat session."""
+        logger.info("=" * 80)
+        logger.info("LIFE COACH V1 - Interactive Chat Session")
+        logger.info("=" * 80)
+        print("\nWelcome to Life Coach v1!")
+        print("I'm here to help you with life coaching, goal setting, motivation, and personal growth.")
+        print("\nCommands:")
+        print("  - Type your question or concern to get coaching advice")
+        print("  - Type 'quit' or 'exit' to end the session")
+        print("  - Type 'clear' to clear conversation history")
+        print("=" * 80)
+        print()
+
+        conversation_history = []
+
+        while True:
+            try:
+                # Get user input
+                user_input = input("\n🧑 You: ").strip()
+
+                if not user_input:
+                    continue
+
+                # Check for exit commands
+                if user_input.lower() in ['quit', 'exit', 'q']:
+                    print("\n👋 Thank you for using Life Coach v1. Take care!")
+                    break
+
+                # Check for clear command
+                if user_input.lower() == 'clear':
+                    conversation_history = []
+                    print("✅ Conversation history cleared.")
+                    continue
+
+                # Generate response with conversation context
+                print("\n🤖 Life Coach: ", end="", flush=True)
+                response = self.generate_response(user_input, conversation_history=conversation_history)
+                print(response)
+
+                # Update conversation history
+                conversation_history.append({
+                    "role": "user",
+                    "content": user_input
+                })
+                conversation_history.append({
+                    "role": "assistant",
+                    "content": response
+                })
+
+            except KeyboardInterrupt:
+                print("\n\n👋 Session interrupted. Goodbye!")
+                break
+            except Exception as e:
+                logger.error(f"Error during chat: {e}")
+                print(f"\n❌ Error: {e}")
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Life Coach v1 - Phi-4 based life coaching assistant"
+    )
+
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["train", "chat", "both"],
+        default="both",
+        help="Mode: train (fine-tune only), chat (chat only), both (train then chat)"
+    )
+
+    parser.add_argument(
+        "--model-name",
+        type=str,
+        default="microsoft/Phi-4",
+        help="Hugging Face model name"
+    )
+
+    parser.add_argument(
+        "--model-path",
+        type=str,
+        default="/data/life_coach_model",
+        help="Path to save/load fine-tuned model"
+    )
+
+    parser.add_argument(
+        "--train-file",
+        type=str,
+        default="cbt_life_coach_improved_50000.jsonl",
+        help="Path to training data file (JSONL format)"
+    )
+
+    parser.add_argument(
+        "--num-samples",
+        type=int,
+        default=-1,
+        help="Number of training samples (default: -1 for all 100,000 from mixed datasets)"
+    )
+
+    parser.add_argument(
+        "--epochs",
+        type=int,
+        default=3,
+        help="Number of training epochs"
+    )
+
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=4,
+        help="Training batch size (default: 4 for memory safety)"
+    )
+
+    parser.add_argument(
+        "--learning-rate",
+        type=float,
+        default=5e-5,
+        help="Learning rate (default: 5e-5, matching quantum server)"
+    )
+
+    parser.add_argument(
+        "--gradient-accumulation",
+        type=int,
+        default=4,
+        help="Gradient accumulation steps (default: 4, effective batch=16)"
+    )
+
+    parser.add_argument(
+        "--force-retrain",
+        action="store_true",
+        help="Force retraining even if fine-tuned model exists"
+    )
+
+    args = parser.parse_args()
+
+    # Clean up GPU memory before starting
+    cleanup_gpu_memory()
+
+    # Initialize model
+    coach = LifeCoachModel(
+        model_name=args.model_name,
+        model_save_path=args.model_path,
+        train_file=args.train_file
+    )
+
+    # Load tokenizer
+    coach.load_tokenizer()
+
+    # Check if fine-tuned model already exists
+    model_exists = coach.model_save_path.exists() and (coach.model_save_path / "adapter_model.safetensors").exists()
+
+    # Training mode
+    if args.mode in ["train", "both"]:
+        # Check if we should skip training
+        if model_exists and not args.force_retrain:
+            logger.info("=" * 80)
+            logger.info("FINE-TUNED MODEL ALREADY EXISTS")
+            logger.info("=" * 80)
+            logger.info(f"Found existing model at: {coach.model_save_path}")
+            logger.info("Skipping training. Loading existing model...")
+            logger.info("(Use --force-retrain to retrain from scratch)")
+            logger.info("=" * 80)
+
+            # Load the existing fine-tuned model
+            coach.load_model(fine_tuned=True)
+        else:
+            if args.force_retrain and model_exists:
+                logger.info("=" * 80)
+                logger.info("FORCING RETRAINING (--force-retrain flag set)")
+                logger.info("=" * 80)
+
+            # Load base model for training
+            coach.load_model(fine_tuned=False)
+
+            # Fine-tune
+            num_samples = None if args.num_samples == -1 else args.num_samples
+            coach.fine_tune(
+                num_samples=num_samples,
+                epochs=args.epochs,
+                batch_size=args.batch_size,
+                learning_rate=args.learning_rate,
+                gradient_accumulation_steps=args.gradient_accumulation
+            )
+
+            # For "both" mode, reload the fine-tuned model for chat
+            if args.mode == "both":
+                logger.info("Reloading fine-tuned model for chat...")
+                coach.load_model(fine_tuned=True)
+
+        # If only training mode, exit
+        if args.mode == "train":
+            logger.info("Training complete. Use --mode chat to start chatting.")
+            return
+
+    # Chat mode
+    elif args.mode == "chat":
+        if not model_exists:
+            logger.error("=" * 80)
+            logger.error("ERROR: No fine-tuned model found!")
+            logger.error("=" * 80)
+            logger.error(f"Expected location: {coach.model_save_path}")
+            logger.error("Please train the model first using:")
+            logger.error("  python3 life_coach_v1.py --mode train")
+            logger.error("=" * 80)
+            return
+
+        # Load fine-tuned model
+        logger.info(f"Loading fine-tuned model from {coach.model_save_path}")
+        coach.load_model(fine_tuned=True)
+
+    # Start interactive chat
+    coach.interactive_chat()
+
+
+if __name__ == "__main__":
+    main()

models.py

@@ -0,0 +1,89 @@
+"""
+Database models for Life Coach Web Application
+"""
+
+from datetime import datetime
+from flask_login import UserMixin
+from flask_sqlalchemy import SQLAlchemy
+from werkzeug.security import generate_password_hash, check_password_hash
+
+# This will be set by app.py
+db = SQLAlchemy()
+
+
+class User(UserMixin, db.Model):
+    """User model for authentication and profile."""
+
+    __tablename__ = 'users'
+
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(80), unique=True, nullable=False, index=True)
+    email = db.Column(db.String(120), unique=True, nullable=False, index=True)
+    password_hash = db.Column(db.String(255), nullable=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+
+    # Relationship with conversations
+    conversations = db.relationship('Conversation', backref='user', lazy=True, cascade='all, delete-orphan')
+
+    def set_password(self, password):
+        """Hash and set the user's password."""
+        self.password_hash = generate_password_hash(password)
+
+    def check_password(self, password):
+        """Verify the user's password."""
+        return check_password_hash(self.password_hash, password)
+
+    def __repr__(self):
+        return f'<User {self.username}>'
+
+
+class Conversation(db.Model):
+    """Conversation model - represents a chat session."""
+
+    __tablename__ = 'conversations'
+
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False, index=True)
+    title = db.Column(db.String(200), default='New Conversation')
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+
+    # Relationship with messages
+    messages = db.relationship('Message', backref='conversation', lazy=True, cascade='all, delete-orphan', order_by='Message.timestamp')
+
+    def get_message_history(self):
+        """Get conversation history formatted for the model."""
+        return [
+            {
+                'role': msg.role,
+                'content': msg.content
+            }
+            for msg in self.messages
+        ]
+
+    def __repr__(self):
+        return f'<Conversation {self.id}: {self.title}>'
+
+
+class Message(db.Model):
+    """Message model - individual messages in a conversation."""
+
+    __tablename__ = 'messages'
+
+    id = db.Column(db.Integer, primary_key=True)
+    conversation_id = db.Column(db.Integer, db.ForeignKey('conversations.id'), nullable=False, index=True)
+    role = db.Column(db.String(20), nullable=False)  # 'user' or 'assistant'
+    content = db.Column(db.Text, nullable=False)
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+
+    def to_dict(self):
+        """Convert message to dictionary for JSON serialization."""
+        return {
+            'id': self.id,
+            'role': self.role,
+            'content': self.content,
+            'timestamp': self.timestamp.isoformat()
+        }
+
+    def __repr__(self):
+        return f'<Message {self.id}: {self.role}>'

requirements.txt

@@ -0,0 +1,13 @@
+Flask
+Flask-Login
+Flask-SQLAlchemy
+gTTS
+transformers
+torch
+peft
+datasets
+accelerate
+bitsandbytes
+sentencepiece
+Jinja2
+gunicorn

static/css/backup/style-bootstrap.css

@@ -0,0 +1,292 @@
+/* Life Coach - Bootstrap 5 Styles */
+
+:root {
+    --primary-pink: #FF6B9D;
+    --primary-coral: #FFA07A;
+    --secondary-mint: #98D8C8;
+    --secondary-gold: #FFD700;
+    --accent-purple: #9C27B0;
+    --accent-orange: #FF5722;
+    --chat-bg: #F5F5F5;
+    --white: #FFFFFF;
+    --text-dark: #333333;
+    --text-light: #666666;
+    --shadow: rgba(0, 0, 0, 0.1);
+}
+
+/* Global */
+html, body {
+    height: 100%;
+    margin: 0;
+    padding: 0;
+    overflow: hidden;
+}
+
+body {
+    background: linear-gradient(135deg, #E0F7FA 0%, #FFF9C4 100%);
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+}
+
+/* Navbar */
+.navbar {
+    background: linear-gradient(90deg, var(--primary-pink) 0%, var(--primary-coral) 100%) !important;
+    box-shadow: 0 2px 8px var(--shadow);
+}
+
+/* Chat Section */
+.chat-section {
+    height: calc(100vh - 56px);
+    overflow: hidden;
+}
+
+.chat-section .container-fluid {
+    height: 100%;
+}
+
+.chat-section .row {
+    height: 100%;
+}
+
+/* Sidebar */
+.chat-sidebar {
+    background: linear-gradient(180deg, var(--primary-pink) 0%, var(--accent-purple) 100%);
+    color: var(--white);
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    overflow: hidden;
+}
+
+.sidebar-header {
+    padding: 1.5rem;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.2);
+    flex-shrink: 0;
+}
+
+.sidebar-content {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: hidden;
+    padding: 0.5rem;
+}
+
+.conversation-item {
+    padding: 1rem;
+    margin-bottom: 0.5rem;
+    border-radius: 10px;
+    cursor: pointer;
+    transition: all 0.2s;
+    background: rgba(255, 255, 255, 0.1);
+    position: relative;
+}
+
+.conversation-item:hover {
+    background: rgba(255, 255, 255, 0.2);
+    transform: translateX(5px);
+}
+
+.conversation-item.active {
+    background: var(--white);
+    color: var(--primary-pink);
+    box-shadow: 0 4px 12px var(--shadow);
+}
+
+.conversation-title {
+    font-weight: bold;
+    margin-bottom: 0.25rem;
+    font-size: 0.95rem;
+}
+
+.conversation-meta {
+    font-size: 0.85rem;
+    opacity: 0.8;
+}
+
+.conversation-delete {
+    position: absolute;
+    top: 0.5rem;
+    right: 0.5rem;
+    background: rgba(255, 82, 82, 0.8);
+    color: white;
+    border: none;
+    border-radius: 50%;
+    width: 24px;
+    height: 24px;
+    display: none;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    font-size: 0.75rem;
+}
+
+.conversation-item:hover .conversation-delete {
+    display: flex;
+}
+
+/* Chat Main */
+.chat-main {
+    background: var(--chat-bg);
+    height: 100%;
+    overflow: hidden;
+}
+
+.chat-header {
+    background: linear-gradient(90deg, var(--secondary-mint) 0%, var(--secondary-gold) 100%);
+    padding: 1.5rem;
+    border-bottom: 3px solid var(--accent-orange);
+    flex-shrink: 0;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.chat-messages {
+    overflow-y: auto;
+    overflow-x: hidden;
+    padding: 2rem;
+    background: var(--chat-bg);
+}
+
+.chat-input-container {
+    background: var(--white);
+    padding: 1.5rem;
+    border-top: 2px solid var(--secondary-mint);
+    flex-shrink: 0;
+}
+
+/* Messages */
+.message-bubble {
+    display: flex;
+    margin-bottom: 1.5rem;
+    animation: slideIn 0.3s ease-out;
+}
+
+@keyframes slideIn {
+    from {
+        opacity: 0;
+        transform: translateX(-20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateX(0);
+    }
+}
+
+.message-bubble.user {
+    flex-direction: row-reverse;
+}
+
+.message-avatar {
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.2rem;
+    flex-shrink: 0;
+}
+
+.message-bubble.user .message-avatar {
+    background: linear-gradient(135deg, var(--accent-purple) 0%, var(--primary-pink) 100%);
+    color: var(--white);
+    margin-left: 1rem;
+}
+
+.message-bubble.assistant .message-avatar {
+    background: linear-gradient(135deg, var(--secondary-mint) 0%, var(--secondary-gold) 100%);
+    color: var(--text-dark);
+    margin-right: 1rem;
+}
+
+.message-content {
+    max-width: 70%;
+}
+
+.message-text {
+    padding: 1rem 1.25rem;
+    border-radius: 18px;
+    word-wrap: break-word;
+    white-space: pre-wrap;
+}
+
+.message-bubble.user .message-text {
+    background: linear-gradient(135deg, var(--primary-pink) 0%, var(--accent-purple) 100%);
+    color: var(--white);
+}
+
+.message-bubble.assistant .message-text {
+    background: var(--white);
+    color: var(--text-dark);
+    box-shadow: 0 2px 8px var(--shadow);
+}
+
+.message-time {
+    font-size: 0.75rem;
+    color: var(--text-light);
+    margin-top: 0.25rem;
+    padding: 0 0.5rem;
+}
+
+.message-bubble.user .message-time {
+    text-align: right;
+}
+
+/* Input */
+.chat-input {
+    border: 2px solid var(--secondary-mint);
+    border-radius: 25px;
+    padding: 0.75rem 1.5rem;
+}
+
+.chat-input:focus {
+    border-color: var(--primary-pink);
+    box-shadow: 0 0 0 0.2rem rgba(255, 107, 157, 0.25);
+}
+
+.send-button {
+    background: linear-gradient(135deg, var(--primary-pink) 0%, var(--primary-coral) 100%);
+    border: none;
+    border-radius: 25px;
+    padding: 0.75rem 1.5rem;
+    color: white;
+    font-weight: bold;
+    white-space: nowrap;
+}
+
+.send-button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px var(--shadow);
+}
+
+/* Scrollbar */
+.chat-messages::-webkit-scrollbar,
+.sidebar-content::-webkit-scrollbar {
+    width: 8px;
+}
+
+.chat-messages::-webkit-scrollbar-track,
+.sidebar-content::-webkit-scrollbar-track {
+    background: rgba(0, 0, 0, 0.05);
+}
+
+.chat-messages::-webkit-scrollbar-thumb {
+    background: var(--primary-pink);
+    border-radius: 10px;
+}
+
+.sidebar-content::-webkit-scrollbar-thumb {
+    background: rgba(255, 255, 255, 0.3);
+    border-radius: 10px;
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .chat-sidebar {
+        display: none;
+    }
+
+    .message-content {
+        max-width: 85%;
+    }
+}

static/css/backup/style-clean.css

@@ -0,0 +1,469 @@
+/* Life Coach - Clean CSS (NO Framework) */
+
+/* ===== RESET & BASICS ===== */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background: linear-gradient(135deg, #E0F7FA 0%, #FFF9C4 100%);
+    min-height: 100vh;
+    color: #333;
+}
+
+/* ===== COLOR VARIABLES ===== */
+:root {
+    --primary-pink: #FF6B9D;
+    --primary-coral: #FFA07A;
+    --secondary-mint: #98D8C8;
+    --secondary-gold: #FFD700;
+    --accent-purple: #9C27B0;
+    --accent-orange: #FF5722;
+    --bg-gradient-start: #E0F7FA;
+    --bg-gradient-end: #FFF9C4;
+    --chat-bg: #F5F5F5;
+    --white: #FFFFFF;
+    --text-dark: #333333;
+    --text-light: #666666;
+    --shadow: rgba(0, 0, 0, 0.1);
+}
+
+/* ===== NAVBAR ===== */
+.navbar {
+    background: linear-gradient(90deg, var(--primary-pink) 0%, var(--primary-coral) 100%);
+    padding: 1rem 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    box-shadow: 0 2px 8px var(--shadow);
+}
+
+.navbar-brand {
+    color: var(--white);
+    font-size: 1.5rem;
+    font-weight: bold;
+    text-decoration: none;
+}
+
+.navbar-menu {
+    display: flex;
+    gap: 1rem;
+    align-items: center;
+}
+
+.navbar-item {
+    color: var(--white);
+    text-decoration: none;
+    padding: 0.5rem 1rem;
+    border-radius: 5px;
+    transition: background 0.2s;
+}
+
+.navbar-item:hover {
+    background: rgba(255, 255, 255, 0.2);
+}
+
+/* ===== BUTTONS ===== */
+.button {
+    padding: 0.5rem 1rem;
+    border: none;
+    border-radius: 5px;
+    cursor: pointer;
+    font-size: 1rem;
+    transition: all 0.2s;
+}
+
+.button-primary {
+    background: linear-gradient(135deg, var(--primary-pink) 0%, var(--primary-coral) 100%);
+    color: white;
+}
+
+.button-primary:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px var(--shadow);
+}
+
+/* ===== AUTH PAGES ===== */
+.auth-container {
+    min-height: calc(100vh - 200px);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 2rem;
+}
+
+.auth-box {
+    background: var(--white);
+    padding: 2.5rem;
+    border-radius: 15px;
+    box-shadow: 0 8px 24px var(--shadow);
+    width: 100%;
+    max-width: 400px;
+}
+
+.auth-box h1 {
+    text-align: center;
+    margin-bottom: 2rem;
+    color: var(--primary-pink);
+}
+
+.form-group {
+    margin-bottom: 1.5rem;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 0.5rem;
+    font-weight: 600;
+    color: var(--text-dark);
+}
+
+.form-group input {
+    width: 100%;
+    padding: 0.75rem;
+    border: 2px solid #ddd;
+    border-radius: 5px;
+    font-size: 1rem;
+}
+
+.form-group input:focus {
+    outline: none;
+    border-color: var(--primary-pink);
+}
+
+.button-full {
+    width: 100%;
+    padding: 0.75rem;
+}
+
+/* ===== CHAT LAYOUT ===== */
+.chat-section {
+    height: calc(100vh - 60px);
+    padding: 0;
+    overflow: hidden;
+}
+
+.chat-container {
+    height: 100%;
+    display: flex;
+    background: var(--white);
+    box-shadow: 0 8px 32px var(--shadow);
+}
+
+/* ===== SIDEBAR ===== */
+.sidebar {
+    width: 300px;
+    flex-shrink: 0;
+    background: linear-gradient(180deg, var(--primary-pink) 0%, var(--accent-purple) 100%);
+    color: var(--white);
+    display: flex;
+    flex-direction: column;
+}
+
+.sidebar-header {
+    padding: 1.5rem;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.2);
+}
+
+.sidebar-header h2 {
+    margin-bottom: 1rem;
+    font-size: 1.2rem;
+}
+
+.sidebar-content {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.5rem;
+}
+
+.conversation-item {
+    padding: 1rem;
+    margin-bottom: 0.5rem;
+    border-radius: 10px;
+    cursor: pointer;
+    transition: all 0.2s;
+    background: rgba(255, 255, 255, 0.1);
+    position: relative;
+}
+
+.conversation-item:hover {
+    background: rgba(255, 255, 255, 0.2);
+    transform: translateX(5px);
+}
+
+.conversation-item.is-active {
+    background: var(--white);
+    color: var(--primary-pink);
+}
+
+.conversation-title {
+    font-weight: bold;
+    margin-bottom: 0.25rem;
+}
+
+.conversation-meta {
+    font-size: 0.85rem;
+    opacity: 0.8;
+}
+
+.conversation-delete {
+    position: absolute;
+    top: 0.5rem;
+    right: 0.5rem;
+    background: rgba(255, 82, 82, 0.8);
+    color: white;
+    border: none;
+    border-radius: 50%;
+    width: 24px;
+    height: 24px;
+    display: none;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    font-size: 0.75rem;
+}
+
+.conversation-item:hover .conversation-delete {
+    display: flex;
+}
+
+/* ===== CHAT MAIN AREA ===== */
+.chat-main {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    background: var(--chat-bg);
+    height: 100%;
+    overflow: hidden;
+}
+
+.chat-header {
+    flex-shrink: 0;
+    background: linear-gradient(90deg, var(--secondary-mint) 0%, var(--secondary-gold) 100%);
+    padding: 1.5rem;
+    border-bottom: 3px solid var(--accent-orange);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.chat-header h1 {
+    margin: 0;
+    font-size: 1.5rem;
+}
+
+.chat-header p {
+    margin: 0.25rem 0 0 0;
+    font-size: 0.9rem;
+    color: var(--text-light);
+}
+
+.tts-toggle {
+    background: rgba(255, 255, 255, 0.7);
+    padding: 0.5rem 1rem;
+    border-radius: 20px;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.tts-toggle:hover {
+    background: rgba(255, 255, 255, 0.9);
+}
+
+.tts-toggle input[type="checkbox"]:checked ~ .fa-volume-up {
+    color: var(--primary-pink);
+}
+
+/* ===== MESSAGES AREA ===== */
+.chat-messages {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: hidden;
+    padding: 2rem;
+    min-height: 0;
+}
+
+.message-bubble {
+    display: flex;
+    margin-bottom: 1.5rem;
+    animation: slideIn 0.3s ease-out;
+}
+
+@keyframes slideIn {
+    from { opacity: 0; transform: translateX(-20px); }
+    to { opacity: 1; transform: translateX(0); }
+}
+
+.message-bubble.user {
+    flex-direction: row-reverse;
+}
+
+.message-avatar {
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.2rem;
+    flex-shrink: 0;
+}
+
+.message-bubble.user .message-avatar {
+    background: linear-gradient(135deg, var(--accent-purple) 0%, var(--primary-pink) 100%);
+    color: var(--white);
+    margin-left: 1rem;
+}
+
+.message-bubble.assistant .message-avatar {
+    background: linear-gradient(135deg, var(--secondary-mint) 0%, var(--secondary-gold) 100%);
+    color: var(--text-dark);
+    margin-right: 1rem;
+}
+
+.message-content {
+    max-width: 70%;
+}
+
+.message-text {
+    padding: 1rem 1.25rem;
+    border-radius: 18px;
+    word-wrap: break-word;
+    white-space: pre-wrap;
+}
+
+.message-bubble.user .message-text {
+    background: linear-gradient(135deg, var(--primary-pink) 0%, var(--accent-purple) 100%);
+    color: var(--white);
+}
+
+.message-bubble.assistant .message-text {
+    background: var(--white);
+    color: var(--text-dark);
+    box-shadow: 0 2px 8px var(--shadow);
+}
+
+.message-time {
+    font-size: 0.75rem;
+    color: var(--text-light);
+    margin-top: 0.25rem;
+    padding: 0 0.5rem;
+}
+
+.message-bubble.user .message-time {
+    text-align: right;
+}
+
+/* ===== INPUT AREA ===== */
+.chat-input-container {
+    flex-shrink: 0;
+    background: var(--white);
+    padding: 1.5rem;
+    border-top: 2px solid var(--secondary-mint);
+}
+
+.chat-form {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.chat-input {
+    flex: 1;
+    padding: 0.75rem 1.5rem;
+    border: 2px solid var(--secondary-mint);
+    border-radius: 25px;
+    font-size: 1rem;
+}
+
+.chat-input:focus {
+    outline: none;
+    border-color: var(--primary-pink);
+}
+
+.send-button {
+    padding: 0.75rem 1.5rem;
+    background: linear-gradient(135deg, var(--primary-pink) 0%, var(--primary-coral) 100%);
+    color: white;
+    border: none;
+    border-radius: 25px;
+    cursor: pointer;
+    font-weight: bold;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.send-button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px var(--shadow);
+}
+
+/* ===== LOADING ===== */
+.loading-indicator {
+    text-align: center;
+    margin-top: 1rem;
+    display: none;
+}
+
+.loader-wrapper {
+    display: inline-flex;
+    align-items: center;
+    gap: 1rem;
+    padding: 0.75rem 1.5rem;
+    background: var(--white);
+    border-radius: 25px;
+    box-shadow: 0 4px 12px var(--shadow);
+}
+
+.loader {
+    border: 3px solid rgba(255, 107, 157, 0.2);
+    border-top: 3px solid var(--primary-pink);
+    border-radius: 50%;
+    width: 24px;
+    height: 24px;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* ===== SCROLLBAR ===== */
+.chat-messages::-webkit-scrollbar,
+.sidebar-content::-webkit-scrollbar {
+    width: 8px;
+}
+
+.chat-messages::-webkit-scrollbar-track,
+.sidebar-content::-webkit-scrollbar-track {
+    background: rgba(0, 0, 0, 0.05);
+}
+
+.chat-messages::-webkit-scrollbar-thumb {
+    background: var(--primary-pink);
+    border-radius: 10px;
+}
+
+.sidebar-content::-webkit-scrollbar-thumb {
+    background: rgba(255, 255, 255, 0.3);
+    border-radius: 10px;
+}
+
+/* ===== RESPONSIVE ===== */
+@media screen and (max-width: 768px) {
+    .sidebar {
+        display: none;
+    }
+
+    .message-content {
+        max-width: 85%;
+    }
+}

static/css/style.css

@@ -0,0 +1,433 @@
+/* Life Coach - Bright & Playful CSS Styles */
+
+:root {
+    --primary-pink: #FF6B9D;
+    --primary-coral: #FFA07A;
+    --secondary-mint: #98D8C8;
+    --secondary-gold: #FFD700;
+    --accent-purple: #9C27B0;
+    --accent-orange: #FF57222;
+    --bg-gradient-start: #E0F7FA;
+    --bg-gradient-end: #FFF9C4;
+    --chat-bg: #F5F5F5;
+    --white: #FFFFFF;
+    --text-dark: #333333;
+    --text-light: #666666;
+    --shadow: rgba(0, 0, 0, 0.1);
+}
+
+/* Global */
+body {
+    background: linear-gradient(135deg, var(--bg-gradient-start) 0%, var(--bg-gradient-end) 100%);
+    min-height: 100vh;
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    margin: 0;
+    padding: 0;
+}
+
+/* Navbar */
+.navbar.is-primary {
+    background: linear-gradient(90deg, var(--primary-pink) 0%, var(--primary-coral) 100%) !important;
+}
+
+.button.is-primary {
+    background: linear-gradient(135deg, var(--primary-pink) 0%, var(--primary-coral) 100%);
+    border: none;
+    transition: transform 0.2s, box-shadow 0.2s;
+}
+
+.button.is-primary:hover {
+    background: linear-gradient(135deg, var(--primary-coral) 0%, var(--primary-pink) 100%);
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px var(--shadow);
+}
+
+.button.is-link {
+    background: linear-gradient(135deg, var(--secondary-mint) 0%, var(--secondary-gold) 100%);
+    border: none;
+    color: var(--text-dark);
+    font-weight: bold;
+}
+
+.button.is-link:hover {
+    background: linear-gradient(135deg, var(--secondary-gold) 0%, var(--secondary-mint) 100%);
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px var(--shadow);
+}
+
+/* Auth Pages */
+.auth-box {
+    border-radius: 15px;
+    box-shadow: 0 8px 24px var(--shadow);
+    background: var(--white);
+    padding: 2.5rem;
+}
+
+.auth-box .input:focus {
+    border-color: var(--primary-pink);
+    box-shadow: 0 0 0 0.125em rgba(255, 107, 157, 0.25);
+}
+
+/* === FIX LAYOUT: Full Height Chat === */
+.chat-section {
+    padding: 0 !important;
+    margin: 0 !important;
+    height: calc(100vh - 52px);
+}
+
+.chat-container {
+    height: 100%;
+    background: var(--white);
+    border-radius: 10px;
+    overflow: hidden;
+    box-shadow: 0 8px 32px var(--shadow);
+    padding: 0 !important;
+    margin: 0 !important;
+}
+
+.chat-layout {
+    display: flex;
+    width: 100%;
+    height: 100%;
+}
+
+.chat-layout .sidebar {
+    width: 300px;
+    flex-shrink: 0;
+    background: linear-gradient(180deg, var(--primary-pink) 0%, var(--accent-purple) 100%);
+    color: var(--white);
+    display: flex;
+    flex-direction: column;
+    border-right: 1px solid rgba(0, 0, 0, 0.1);
+}
+
+.chat-layout .chat-main {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    background: var(--chat-bg);
+    min-width: 0;
+}
+
+/* Sidebar */
+.sidebar-header {
+    padding: 1.5rem;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.2);
+}
+
+.sidebar-header .title {
+    color: var(--white);
+    margin-bottom: 1rem;
+}
+
+.sidebar-content {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.5rem;
+}
+
+.conversation-item {
+    padding: 1rem;
+    margin-bottom: 0.5rem;
+    border-radius: 10px;
+    cursor: pointer;
+    transition: all 0.2s;
+    background: rgba(255, 255, 255, 0.1);
+    position: relative;
+    display: flex;
+    flex-direction: column;
+}
+
+.conversation-item:hover {
+    background: rgba(255, 255, 255, 0.2);
+    transform: translateX(5px);
+}
+
+.conversation-item.is-active {
+    background: var(--white);
+    color: var(--primary-pink);
+    box-shadow: 0 4px 12px var(--shadow);
+}
+
+.conversation-title {
+    font-weight: bold;
+    margin-bottom: 0.25rem;
+}
+
+.conversation-meta {
+    font-size: 0.85rem;
+    opacity: 0.8;
+}
+
+.conversation-delete {
+    position: absolute;
+    top: 0.5rem;
+    right: 0.5rem;
+    background: rgba(255, 82, 82, 0.8);
+    color: white;
+    border: none;
+    border-radius: 50%;
+    width: 24px;
+    height: 24px;
+    display: none;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    font-size: 0.75rem;
+}
+
+.conversation-item:hover .conversation-delete {
+    display: flex;
+}
+
+.conversation-delete:hover {
+    background: rgba(255, 20, 20, 1);
+    transform: scale(1.1);
+}
+
+/* Chat Header */
+.chat-header {
+    background: linear-gradient(90deg, var(--secondary-mint) 0%, var(--secondary-gold) 100%);
+    padding: 1.5rem;
+    border-bottom: 3px solid var(--accent-orange);
+    box-shadow: 0 2px 8px var(--shadow);
+    flex-shrink: 0;
+    min-height: 80px;
+}
+
+.chat-header > div {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.chat-header .checkbox {
+    background: rgba(255, 255, 255, 0.7);
+    padding: 0.5rem 1rem;
+    border-radius: 20px;
+    transition: all 0.2s;
+    cursor: pointer;
+    white-space: nowrap;
+}
+
+.chat-header .checkbox:hover {
+    background: rgba(255, 255, 255, 0.9);
+    transform: scale(1.05);
+}
+
+/* Messages Area */
+.chat-messages {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: hidden;
+    padding: 2rem;
+    scroll-behavior: smooth;
+    min-height: 0;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+}
+
+/* Disabilita centramento quando ci sono messaggi */
+.chat-messages:has(.message-bubble),
+.chat-messages.has-messages {
+    justify-content: flex-start !important;
+    align-items: flex-start !important;
+}
+
+.welcome-message {
+    text-align: center;
+    padding: 3rem 2rem;
+    animation: fadeIn 0.5s ease-in;
+    width: 100%;
+    max-width: 600px;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(20px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+/* Message Bubbles */
+.message-bubble {
+    display: flex;
+    margin-bottom: 1.5rem;
+    animation: slideIn 0.3s ease-out;
+    width: 100%;
+    max-width: 100%;
+}
+
+@keyframes slideIn {
+    from { opacity: 0; transform: translateX(-20px); }
+    to { opacity: 1; transform: translateX(0); }
+}
+
+.message-bubble.user {
+    flex-direction: row-reverse;
+}
+
+.message-avatar {
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.2rem;
+    flex-shrink: 0;
+}
+
+.message-bubble.user .message-avatar {
+    background: linear-gradient(135deg, var(--accent-purple) 0%, var(--primary-pink) 100%);
+    color: var(--white);
+    margin-left: 1rem;
+}
+
+.message-bubble.assistant .message-avatar {
+    background: linear-gradient(135deg, var(--secondary-mint) 0%, var(--secondary-gold) 100%);
+    color: var(--text-dark);
+    margin-right: 1rem;
+}
+
+.message-content {
+    max-width: 70%;
+    width: fit-content;
+}
+
+.message-text {
+    padding: 1rem 1.25rem;
+    border-radius: 18px;
+    word-wrap: break-word;
+    white-space: pre-wrap;
+}
+
+.message-bubble.user .message-text {
+    background: linear-gradient(135deg, var(--primary-pink) 0%, var(--accent-purple) 100%);
+    color: var(--white);
+    border-bottom-right-radius: 4px;
+}
+
+.message-bubble.assistant .message-text {
+    background: var(--white);
+    color: var(--text-dark);
+    border-bottom-left-radius: 4px;
+    box-shadow: 0 2px 8px var(--shadow);
+}
+
+.message-time {
+    font-size: 0.75rem;
+    color: var(--text-light);
+    margin-top: 0.25rem;
+    padding: 0 0.5rem;
+}
+
+.message-bubble.user .message-time {
+    text-align: right;
+}
+
+/* Input */
+.chat-input-container {
+    background: var(--white);
+    padding: 1.5rem;
+    border-top: 2px solid var(--secondary-mint);
+    box-shadow: 0 -2px 8px var(--shadow);
+    flex-shrink: 0;
+    min-height: 100px;
+}
+
+.chat-input-container .input {
+    border-radius: 25px;
+    border: 2px solid var(--secondary-mint);
+    padding-left: 1.5rem;
+}
+
+.chat-input-container .input:focus {
+    border-color: var(--primary-pink);
+    box-shadow: 0 0 0 0.125em rgba(255, 107, 157, 0.25);
+}
+
+.chat-input-container .button {
+    border-radius: 25px;
+    font-weight: bold;
+}
+
+/* Loading */
+.loading-indicator {
+    text-align: center;
+    margin-top: 1rem;
+}
+
+.loader-wrapper {
+    display: inline-flex;
+    align-items: center;
+    gap: 1rem;
+    padding: 0.75rem 1.5rem;
+    background: var(--white);
+    border-radius: 25px;
+    box-shadow: 0 4px 12px var(--shadow);
+}
+
+.loader {
+    border: 3px solid rgba(255, 107, 157, 0.2);
+    border-top: 3px solid var(--primary-pink);
+    border-radius: 50%;
+    width: 24px;
+    height: 24px;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+/* Scrollbar */
+.chat-messages::-webkit-scrollbar,
+.sidebar-content::-webkit-scrollbar {
+    width: 8px;
+}
+
+.chat-messages::-webkit-scrollbar-track,
+.sidebar-content::-webkit-scrollbar-track {
+    background: rgba(0, 0, 0, 0.05);
+}
+
+.chat-messages::-webkit-scrollbar-thumb {
+    background: var(--primary-pink);
+    border-radius: 10px;
+}
+
+.sidebar-content::-webkit-scrollbar-thumb {
+    background: rgba(255, 255, 255, 0.3);
+    border-radius: 10px;
+}
+
+/* Mobile */
+@media (max-width: 768px) {
+    .chat-layout .sidebar {
+        display: none;
+    }
+    .chat-header {
+        padding: 1rem;
+    }
+    .chat-header > div {
+        flex-direction: column;
+        gap: 0.5rem;
+    }
+    .message-content {
+        max-width: 85%;
+    }
+}
+
+/* Footer */
+.footer {
+    background: linear-gradient(90deg, var(--primary-pink) 0%, var(--accent-purple) 100%);
+    color: var(--white);
+    padding: 2rem;
+}
+
+.footer strong {
+    color: var(--white);
+}

static/js/chat.js

@@ -0,0 +1,560 @@
+/**
+ * Life Coach Chat Interface JavaScript
+ * Handles AJAX communication with the Flask backend
+ */
+
+// Global state
+let currentConversationId = null;
+let ttsEnabled = false;
+let currentAudio = null;
+
+// Initialize when DOM is loaded
+document.addEventListener('DOMContentLoaded', () => {
+    // Get current conversation ID from hidden input
+    const conversationIdInput = document.getElementById('currentConversationId');
+    if (conversationIdInput) {
+        currentConversationId = parseInt(conversationIdInput.value);
+    }
+
+    // Setup event listeners
+    setupEventListeners();
+
+    // Load current conversation messages
+    if (currentConversationId) {
+        loadConversation(currentConversationId);
+    }
+
+    // Load TTS preference from localStorage
+    const ttsToggle = document.getElementById('ttsToggle');
+    if (ttsToggle) {
+        const savedTtsPreference = localStorage.getItem('ttsEnabled');
+        if (savedTtsPreference === 'true') {
+            ttsToggle.checked = true;
+            ttsEnabled = true;
+        }
+    }
+});
+
+
+/**
+ * Setup all event listeners
+ */
+function setupEventListeners() {
+    // Chat form submission
+    const chatForm = document.getElementById('chatForm');
+    if (chatForm) {
+        chatForm.addEventListener('submit', handleSendMessage);
+    }
+
+    // New conversation button
+    const newConvBtn = document.getElementById('newConversationBtn');
+    if (newConvBtn) {
+        newConvBtn.addEventListener('click', handleNewConversation);
+    }
+
+    // Conversation item clicks
+    const conversationItems = document.querySelectorAll('.conversation-item');
+    conversationItems.forEach(item => {
+        item.addEventListener('click', (e) => {
+            // Don't switch conversation if clicking delete button
+            if (e.target.closest('.conversation-delete')) {
+                return;
+            }
+            const convId = parseInt(item.dataset.conversationId);
+            switchConversation(convId);
+        });
+    });
+
+    // Delete conversation buttons
+    const deleteButtons = document.querySelectorAll('.conversation-delete');
+    deleteButtons.forEach(btn => {
+        btn.addEventListener('click', (e) => {
+            e.stopPropagation();  // Prevent triggering conversation switch
+            const convId = parseInt(btn.dataset.conversationId);
+            handleDeleteConversation(convId);
+        });
+    });
+
+    // Enter key in input (already handled by form submit, but for custom behavior)
+    const messageInput = document.getElementById('messageInput');
+    if (messageInput) {
+        messageInput.addEventListener('keydown', (e) => {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                chatForm.dispatchEvent(new Event('submit'));
+            }
+        });
+    }
+
+    // TTS toggle
+    const ttsToggle = document.getElementById('ttsToggle');
+    if (ttsToggle) {
+        ttsToggle.addEventListener('change', (e) => {
+            ttsEnabled = e.target.checked;
+            // Save preference to localStorage
+            localStorage.setItem('ttsEnabled', ttsEnabled);
+
+            // Stop any currently playing audio when disabling
+            if (!ttsEnabled && currentAudio) {
+                currentAudio.pause();
+                currentAudio = null;
+            }
+        });
+    }
+}
+
+
+/**
+ * Handle sending a message
+ */
+async function handleSendMessage(e) {
+    e.preventDefault();
+
+    const messageInput = document.getElementById('messageInput');
+    const sendBtn = document.getElementById('sendBtn');
+    const loadingIndicator = document.getElementById('loadingIndicator');
+
+    const message = messageInput.value.trim();
+    if (!message) return;
+
+    // Disable input and show loading
+    messageInput.disabled = true;
+    sendBtn.disabled = true;
+    loadingIndicator.style.display = 'block';
+
+    // Clear input immediately for better UX
+    messageInput.value = '';
+
+    // Add user message to UI immediately
+    addMessageToUI({
+        role: 'user',
+        content: message,
+        timestamp: new Date().toISOString()
+    });
+
+    try {
+        // Send message to backend
+        const response = await fetch('/chat/api/send', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                message: message,
+                conversation_id: currentConversationId
+            })
+        });
+
+        const data = await response.json();
+
+        if (data.success) {
+            // Update current conversation ID if it was a new conversation
+            if (!currentConversationId) {
+                currentConversationId = data.conversation_id;
+                document.getElementById('currentConversationId').value = currentConversationId;
+            }
+
+            // Add assistant message to UI
+            addMessageToUI(data.assistant_message);
+
+            // Generate and play TTS if enabled
+            if (ttsEnabled) {
+                playTextToSpeech(data.assistant_message.content);
+            }
+
+            // Update conversation list if needed
+            refreshConversationList();
+
+        } else {
+            showError(data.error || 'Failed to send message');
+            // Remove the user message we added optimistically
+            const lastMessage = document.querySelector('.message-bubble:last-child');
+            if (lastMessage && lastMessage.classList.contains('user')) {
+                lastMessage.remove();
+            }
+        }
+
+    } catch (error) {
+        console.error('Error sending message:', error);
+        showError('Network error. Please try again.');
+        // Remove the user message we added optimistically
+        const lastMessage = document.querySelector('.message-bubble:last-child');
+        if (lastMessage && lastMessage.classList.contains('user')) {
+            lastMessage.remove();
+        }
+    } finally {
+        // Re-enable input and hide loading
+        messageInput.disabled = false;
+        sendBtn.disabled = false;
+        loadingIndicator.style.display = 'none';
+        messageInput.focus();
+    }
+}
+
+
+/**
+ * Add a message to the UI
+ */
+function addMessageToUI(message) {
+    const chatMessages = document.getElementById('chatMessages');
+
+    // Remove welcome message if it exists
+    const welcomeMessage = chatMessages.querySelector('.welcome-message');
+    if (welcomeMessage) {
+        welcomeMessage.remove();
+    }
+
+    // Create message bubble
+    const messageBubble = document.createElement('div');
+    messageBubble.className = `message-bubble ${message.role}`;
+
+    // Format timestamp
+    const timestamp = new Date(message.timestamp);
+    const timeString = timestamp.toLocaleTimeString('en-US', {
+        hour: 'numeric',
+        minute: '2-digit',
+        hour12: true
+    });
+
+    // Create message HTML
+    messageBubble.innerHTML = `
+        <div class="message-avatar">
+            ${message.role === 'user'
+                ? '<i class="fas fa-user"></i>'
+                : '<i class="fas fa-robot"></i>'}
+        </div>
+        <div class="message-content">
+            <div class="message-text">${escapeHtml(message.content)}</div>
+            <div class="message-time">${timeString}</div>
+        </div>
+    `;
+
+    chatMessages.appendChild(messageBubble);
+
+    // Scroll to bottom
+    scrollToBottom();
+}
+
+
+/**
+ * Load a conversation and its messages
+ */
+async function loadConversation(conversationId) {
+    try {
+        const response = await fetch(`/chat/api/conversation/${conversationId}`);
+        const data = await response.json();
+
+        if (data.success) {
+            const conversation = data.conversation;
+
+            // Update UI
+            document.getElementById('chatTitle').textContent = conversation.title;
+            currentConversationId = conversation.id;
+            document.getElementById('currentConversationId').value = currentConversationId;
+
+            // Clear and reload messages
+            const chatMessages = document.getElementById('chatMessages');
+            chatMessages.innerHTML = '';
+
+            if (conversation.messages.length === 0) {
+                // Show welcome message
+                chatMessages.innerHTML = `
+                    <div class="welcome-message">
+                        <div class="has-text-centered">
+                            <i class="fas fa-heart fa-4x has-text-primary mb-4"></i>
+                            <h2 class="title is-3">Welcome to Life Coach!</h2>
+                            <p class="subtitle is-5">I'm here to help you with personal growth, goal setting, and motivation.</p>
+                            <p class="has-text-grey">Start by telling me what's on your mind or what you'd like to work on today.</p>
+                        </div>
+                    </div>
+                `;
+            } else {
+                // Add all messages
+                conversation.messages.forEach(msg => addMessageToUI(msg));
+                // Scroll to bottom after loading all messages
+                scrollToBottom();
+            }
+
+        } else {
+            showError('Failed to load conversation');
+        }
+
+    } catch (error) {
+        console.error('Error loading conversation:', error);
+        showError('Failed to load conversation');
+    }
+}
+
+
+/**
+ * Switch to a different conversation
+ */
+function switchConversation(conversationId) {
+    // Update active state in sidebar
+    document.querySelectorAll('.conversation-item').forEach(item => {
+        item.classList.remove('is-active');
+        if (parseInt(item.dataset.conversationId) === conversationId) {
+            item.classList.add('is-active');
+        }
+    });
+
+    // Load the conversation
+    loadConversation(conversationId);
+}
+
+
+/**
+ * Create a new conversation
+ */
+async function handleNewConversation() {
+    try {
+        const response = await fetch('/chat/api/conversation/new', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+
+        const data = await response.json();
+
+        if (data.success) {
+            // Refresh conversation list
+            await refreshConversationList();
+
+            // Switch to new conversation
+            switchConversation(data.conversation.id);
+
+        } else {
+            showError('Failed to create new conversation');
+        }
+
+    } catch (error) {
+        console.error('Error creating conversation:', error);
+        showError('Failed to create new conversation');
+    }
+}
+
+
+/**
+ * Refresh the conversation list
+ */
+async function refreshConversationList() {
+    try {
+        const response = await fetch('/chat/api/conversations');
+        const data = await response.json();
+
+        if (data.success) {
+            const conversationList = document.getElementById('conversationList');
+            conversationList.innerHTML = '';
+
+            data.conversations.forEach(conv => {
+                const item = document.createElement('div');
+                item.className = 'conversation-item';
+                if (conv.id === currentConversationId) {
+                    item.classList.add('is-active');
+                }
+                item.dataset.conversationId = conv.id;
+
+                item.innerHTML = `
+                    <button class="conversation-delete" data-conversation-id="${conv.id}" title="Delete conversation">
+                        <i class="fas fa-times"></i>
+                    </button>
+                    <div class="conversation-title">
+                        <i class="fas fa-message mr-2"></i>
+                        ${escapeHtml(conv.title)}
+                    </div>
+                    <div class="conversation-meta">
+                        ${conv.message_count} messages
+                    </div>
+                `;
+
+                // Add click handler for conversation item
+                item.addEventListener('click', (e) => {
+                    // Don't switch conversation if clicking delete button
+                    if (e.target.closest('.conversation-delete')) {
+                        return;
+                    }
+                    switchConversation(conv.id);
+                });
+
+                // Add click handler for delete button
+                const deleteBtn = item.querySelector('.conversation-delete');
+                deleteBtn.addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    handleDeleteConversation(conv.id);
+                });
+
+                conversationList.appendChild(item);
+            });
+        }
+
+    } catch (error) {
+        console.error('Error refreshing conversation list:', error);
+    }
+}
+
+
+/**
+ * Delete a conversation
+ */
+async function handleDeleteConversation(conversationId) {
+    // Confirm deletion
+    if (!confirm('Are you sure you want to delete this conversation? This cannot be undone.')) {
+        return;
+    }
+
+    try {
+        const response = await fetch(`/chat/api/conversation/${conversationId}/delete`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+
+        const data = await response.json();
+
+        if (data.success) {
+            // If we deleted the current conversation, switch to a different one
+            if (conversationId === currentConversationId) {
+                // Refresh conversation list first
+                await refreshConversationList();
+
+                // Get the first conversation or create a new one
+                const conversationList = document.getElementById('conversationList');
+                const firstConversation = conversationList.querySelector('.conversation-item');
+
+                if (firstConversation) {
+                    const firstConvId = parseInt(firstConversation.dataset.conversationId);
+                    switchConversation(firstConvId);
+                } else {
+                    // No conversations left, create a new one
+                    await handleNewConversation();
+                }
+            } else {
+                // Just refresh the list
+                await refreshConversationList();
+            }
+        } else {
+            showError(data.error || 'Failed to delete conversation');
+        }
+
+    } catch (error) {
+        console.error('Error deleting conversation:', error);
+        showError('Failed to delete conversation');
+    }
+}
+
+
+/**
+ * Scroll chat messages to bottom
+ */
+function scrollToBottom() {
+    const chatMessages = document.getElementById('chatMessages');
+    // Use setTimeout to ensure DOM has updated
+    setTimeout(() => {
+        chatMessages.scrollTop = chatMessages.scrollHeight;
+    }, 100);
+}
+
+
+/**
+ * Show error notification
+ */
+function showError(message) {
+    // Create notification
+    const notification = document.createElement('div');
+    notification.className = 'notification is-danger is-light';
+    notification.innerHTML = `
+        <button class="delete"></button>
+        ${escapeHtml(message)}
+    `;
+
+    // Add to page
+    const container = document.querySelector('.container') || document.body;
+    container.insertBefore(notification, container.firstChild);
+
+    // Add delete functionality
+    notification.querySelector('.delete').addEventListener('click', () => {
+        notification.remove();
+    });
+
+    // Auto-dismiss after 5 seconds
+    setTimeout(() => {
+        notification.remove();
+    }, 5000);
+}
+
+
+/**
+ * Escape HTML to prevent XSS
+ */
+function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
+
+/**
+ * Format timestamp to readable string
+ */
+function formatTimestamp(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleString('en-US', {
+        month: 'short',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: '2-digit',
+        hour12: true
+    });
+}
+
+
+/**
+ * Generate and play text-to-speech audio
+ */
+async function playTextToSpeech(text) {
+    try {
+        // Stop any currently playing audio
+        if (currentAudio) {
+            currentAudio.pause();
+            currentAudio = null;
+        }
+
+        // Request TTS generation from server
+        const response = await fetch('/chat/api/tts/generate', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ text: text })
+        });
+
+        const data = await response.json();
+
+        if (data.success && data.audio_url) {
+            // Create and play audio element
+            currentAudio = new Audio(data.audio_url);
+
+            // Add event listener for when audio ends
+            currentAudio.addEventListener('ended', () => {
+                currentAudio = null;
+            });
+
+            // Add error handler
+            currentAudio.addEventListener('error', (e) => {
+                console.error('Audio playback error:', e);
+                currentAudio = null;
+            });
+
+            // Play the audio
+            await currentAudio.play();
+
+        } else {
+            console.error('TTS generation failed:', data.error);
+        }
+
+    } catch (error) {
+        console.error('Error playing TTS:', error);
+    }
+}

templates/base.html

@@ -0,0 +1,128 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}Life Coach{% endblock %} - AI Life Coaching Assistant</title>
+
+    <!-- Bulma CSS -->
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bulma@0.9.4/css/bulma.min.css">
+
+    <!-- Font Awesome Icons -->
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+
+    <!-- Custom CSS -->
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}?v={{ range(1, 10000) | random }}">
+
+    {% block extra_head %}{% endblock %}
+</head>
+<body>
+    <!-- Navbar -->
+    <nav class="navbar is-primary" role="navigation" aria-label="main navigation">
+        <div class="navbar-brand">
+            <a class="navbar-item" href="{{ url_for('index') }}">
+                <i class="fas fa-heart mr-2"></i>
+                <strong>Life Coach</strong>
+            </a>
+
+            <a role="button" class="navbar-burger" aria-label="menu" aria-expanded="false" data-target="navbarMenu">
+                <span aria-hidden="true"></span>
+                <span aria-hidden="true"></span>
+                <span aria-hidden="true"></span>
+            </a>
+        </div>
+
+        <div id="navbarMenu" class="navbar-menu">
+            <div class="navbar-end">
+                {% if current_user.is_authenticated %}
+                    <div class="navbar-item has-dropdown is-hoverable">
+                        <a class="navbar-link">
+                            <i class="fas fa-user mr-2"></i>
+                            {{ current_user.username }}
+                        </a>
+
+                        <div class="navbar-dropdown">
+                            <a class="navbar-item" href="{{ url_for('chat.chat_interface') }}">
+                                <i class="fas fa-comments mr-2"></i>
+                                Chat
+                            </a>
+                            <hr class="navbar-divider">
+                            <a class="navbar-item" href="{{ url_for('auth.logout') }}">
+                                <i class="fas fa-sign-out-alt mr-2"></i>
+                                Logout
+                            </a>
+                        </div>
+                    </div>
+                {% else %}
+                    <a class="navbar-item" href="{{ url_for('auth.login') }}">
+                        <i class="fas fa-sign-in-alt mr-2"></i>
+                        Login
+                    </a>
+                    <a class="navbar-item" href="{{ url_for('auth.register') }}">
+                        <i class="fas fa-user-plus mr-2"></i>
+                        Register
+                    </a>
+                {% endif %}
+            </div>
+        </div>
+    </nav>
+
+    <!-- Flash Messages -->
+    {% with messages = get_flashed_messages(with_categories=true) %}
+        {% if messages %}
+            <div class="container mt-4">
+                {% for category, message in messages %}
+                    <div class="notification is-{{ category }} is-light">
+                        <button class="delete"></button>
+                        {{ message }}
+                    </div>
+                {% endfor %}
+            </div>
+        {% endif %}
+    {% endwith %}
+
+    <!-- Main Content -->
+    <main>
+        {% block content %}{% endblock %}
+    </main>
+
+    <!-- Footer -->
+    <footer class="footer mt-6">
+        <div class="content has-text-centered">
+            <p>
+                <strong>Life Coach</strong> - AI-powered life coaching assistant
+                <br>
+                Powered by Microsoft Phi-4 🤖
+            </p>
+        </div>
+    </footer>
+
+    <!-- Scripts -->
+    <script>
+        // Mobile navbar toggle
+        document.addEventListener('DOMContentLoaded', () => {
+            const $navbarBurgers = Array.prototype.slice.call(document.querySelectorAll('.navbar-burger'), 0);
+
+            $navbarBurgers.forEach( el => {
+                el.addEventListener('click', () => {
+                    const target = el.dataset.target;
+                    const $target = document.getElementById(target);
+                    el.classList.toggle('is-active');
+                    $target.classList.toggle('is-active');
+                });
+            });
+
+            // Auto-dismiss notifications
+            const $notifications = document.querySelectorAll('.notification .delete');
+            $notifications.forEach(($delete) => {
+                const $notification = $delete.parentNode;
+                $delete.addEventListener('click', () => {
+                    $notification.parentNode.removeChild($notification);
+                });
+            });
+        });
+    </script>
+
+    {% block extra_scripts %}{% endblock %}
+</body>
+</html>

templates/chat-clean.html

@@ -0,0 +1,107 @@
+{% extends "base.html" %}
+
+{% block title %}Chat{% endblock %}
+
+{% block content %}
+<div class="chat-section">
+    <div class="container-fluid h-100 p-0">
+        <div class="row g-0 h-100">
+            <!-- Sidebar Column -->
+            <div class="col-md-3 chat-sidebar">
+                <div class="sidebar-header">
+                    <h5 class="text-white mb-3">
+                        <i class="fas fa-comments me-2"></i>Conversations
+                    </h5>
+                    <button class="btn btn-light w-100" id="newConversationBtn">
+                        <i class="fas fa-plus me-2"></i>New Chat
+                    </button>
+                </div>
+
+                <div class="sidebar-content" id="conversationList">
+                    {% for conv in conversations %}
+                    <div class="conversation-item {% if conv.id == current_conversation.id %}active{% endif %}"
+                         data-conversation-id="{{ conv.id }}">
+                        <button class="conversation-delete" data-conversation-id="{{ conv.id }}" title="Delete conversation">
+                            <i class="fas fa-times"></i>
+                        </button>
+                        <div class="conversation-title">
+                            <i class="fas fa-message me-2"></i>{{ conv.title }}
+                        </div>
+                        <div class="conversation-meta">
+                            {{ conv.messages|length }} messages
+                        </div>
+                    </div>
+                    {% endfor %}
+                </div>
+            </div>
+
+            <!-- Main Chat Column -->
+            <div class="col-md-9 d-flex flex-column chat-main">
+                <!-- Chat Header -->
+                <div class="chat-header">
+                    <div>
+                        <h4 class="mb-1" id="chatTitle">{{ current_conversation.title }}</h4>
+                        <p class="mb-0 text-muted small">
+                            <i class="fas fa-user-tie me-1"></i>AI Life Coach - Here to help you grow
+                        </p>
+                    </div>
+                    <div class="form-check form-switch">
+                        <input class="form-check-input" type="checkbox" id="ttsToggle">
+                        <label class="form-check-label" for="ttsToggle">
+                            <i class="fas fa-volume-up me-1"></i>Read Aloud
+                        </label>
+                    </div>
+                </div>
+
+                <!-- Chat Messages -->
+                <div class="chat-messages flex-grow-1" id="chatMessages">
+                    {% if current_conversation.messages|length == 0 %}
+                    <div class="text-center py-5">
+                        <i class="fas fa-heart fa-4x mb-3" style="color: var(--primary-pink);"></i>
+                        <h2>Welcome to Life Coach!</h2>
+                        <p class="text-muted">I'm here to help you with personal growth and motivation.</p>
+                    </div>
+                    {% endif %}
+
+                    {% for message in current_conversation.messages %}
+                    <div class="message-bubble {{ message.role }}">
+                        <div class="message-avatar">
+                            <i class="fas fa-{{ 'user' if message.role == 'user' else 'user-tie' }}"></i>
+                        </div>
+                        <div class="message-content">
+                            <div class="message-text">{{ message.content }}</div>
+                            <div class="message-time">{{ message.timestamp.strftime('%I:%M %p') }}</div>
+                        </div>
+                    </div>
+                    {% endfor %}
+                </div>
+
+                <!-- Chat Input -->
+                <div class="chat-input-container">
+                    <form id="chatForm" class="d-flex gap-2">
+                        <input type="text" class="form-control chat-input" id="messageInput"
+                               placeholder="Type your message here..."
+                               autocomplete="off" required>
+                        <button type="submit" class="btn btn-primary send-button" id="sendBtn">
+                            <i class="fas fa-paper-plane me-2"></i>Send
+                        </button>
+                    </form>
+
+                    <div class="loading-indicator text-center mt-3" id="loadingIndicator" style="display: none;">
+                        <div class="d-inline-flex align-items-center gap-2 bg-white px-4 py-2 rounded-pill shadow">
+                            <div class="spinner-border spinner-border-sm text-primary" role="status"></div>
+                            <span>Thinking...</span>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<input type="hidden" id="currentConversationId" value="{{ current_conversation.id }}">
+{% endblock %}
+
+{% block extra_scripts %}
+<script src="{{ url_for('static', filename='js/chat.js') }}"></script>
+{% endblock %}

templates/chat.html

@@ -0,0 +1,138 @@
+{% extends "base.html" %}
+
+{% block title %}Chat{% endblock %}
+
+{% block content %}
+<section class="section chat-section">
+    <div class="chat-container">
+        <!-- Layout flessibile personalizzato (senza .columns di Bulma) -->
+        <div class="chat-layout">
+
+            <!-- Sidebar -->
+            <aside class="sidebar">
+                <div class="sidebar-header">
+                    <h2 class="title is-5">
+                        <i class="fas fa-comments mr-2"></i>
+                        Conversations
+                    </h2>
+                    <button class="button is-primary is-small" id="newConversationBtn">
+                        <span class="icon">
+                            <i class="fas fa-plus"></i>
+                        </span>
+                        <span>New Chat</span>
+                    </button>
+                </div>
+
+                <div class="sidebar-content" id="conversationList">
+                    {% for conv in conversations %}
+                    <div class="conversation-item {% if conv.id == current_conversation.id %}is-active{% endif %}"
+                         data-conversation-id="{{ conv.id }}">
+                        <button class="conversation-delete" data-conversation-id="{{ conv.id }}" title="Delete conversation">
+                            <i class="fas fa-times"></i>
+                        </button>
+                        <div class="conversation-title">
+                            <i class="fas fa-message mr-2"></i>
+                            {{ conv.title }}
+                        </div>
+                        <div class="conversation-meta">
+                            {{ conv.messages|length }} messages
+                        </div>
+                    </div>
+                    {% endfor %}
+                </div>
+            </aside>
+
+            <!-- Main Chat Area -->
+            <main class="chat-main">
+                <!-- Header -->
+                <header class="chat-header">
+                    <div>
+                        <div>
+                            <h1 class="title is-4 mb-0" id="chatTitle">
+                                {{ current_conversation.title }}
+                            </h1>
+                            <p class="subtitle is-7 has-text-grey">
+                                <i class="fas fa-robot mr-1"></i>
+                                AI Life Coach - Here to help you grow
+                            </p>
+                        </div>
+                        <div class="field">
+                            <label class="checkbox" title="Enable text-to-speech for assistant responses">
+                                <input type="checkbox" id="ttsToggle">
+                                <i class="fas fa-volume-up ml-2"></i>
+                                <span class="ml-1">Read Aloud</span>
+                            </label>
+                        </div>
+                    </div>
+                </header>
+
+                <!-- Messages Area -->
+                <div class="chat-messages" id="chatMessages">
+                    <!-- Welcome Message (solo se non ci sono messaggi) -->
+                    <div class="welcome-message">
+                        <div class="has-text-centered">
+                            <i class="fas fa-heart fa-4x has-text-primary mb-4"></i>
+                            <h2 class="title is-3">Welcome to Life Coach!</h2>
+                            <p class="subtitle is-5">I'm here to help you with personal growth, goal setting, and motivation.</p>
+                            <p class="has-text-grey">Start by telling me what's on your mind or what you'd like to work on today.</p>
+                        </div>
+                    </div>
+
+                    <!-- Messaggi esistenti -->
+                    {% for message in current_conversation.messages %}
+                    <div class="message-bubble {{ message.role }}">
+                        <div class="message-avatar">
+                            {% if message.role == 'user' %}
+                                <i class="fas fa-user"></i>
+                            {% else %}
+                                <i class="fas fa-robot"></i>
+                            {% endif %}
+                        </div>
+                        <div class="message-content">
+                            <div class="message-text">{{ message.content }}</div>
+                            <div class="message-time">{{ message.timestamp.strftime('%I:%M %p') }}</div>
+                        </div>
+                    </div>
+                    {% endfor %}
+                </div>
+
+                <!-- Input Area -->
+                <div class="chat-input-container">
+                    <form id="chatForm">
+                        <div class="field has-addons">
+                            <div class="control is-expanded">
+                                <input class="input is-medium" type="text" id="messageInput"
+                                       placeholder="Type your message here..."
+                                       autocomplete="off" required>
+                            </div>
+                            <div class="control">
+                                <button class="button is-primary is-medium" type="submit" id="sendBtn">
+                                    <span class="icon">
+                                        <i class="fas fa-paper-plane"></i>
+                                    </span>
+                                    <span>Send</span>
+                                </button>
+                            </div>
+                        </div>
+                    </form>
+
+                    <!-- Loading Indicator -->
+                    <div class="loading-indicator" id="loadingIndicator" style="display: none;">
+                        <div class="loader-wrapper">
+                            <div class="loader"></div>
+                            <span>Thinking...</span>
+                        </div>
+                    </div>
+                </div>
+            </main>
+        </div>
+    </div>
+</section>
+
+<!-- ID conversazione corrente per JS -->
+<input type="hidden" id="currentConversationId" value="{{ current_conversation.id }}">
+{% endblock %}
+
+{% block extra_scripts %}
+<script src="{{ url_for('static', filename='js/chat.js') }}?v={{ range(1, 10000) | random }}"></script>
+{% endblock %}

templates/login.html

@@ -0,0 +1,82 @@
+{% extends "base.html" %}
+
+{% block title %}Login{% endblock %}
+
+{% block content %}
+<section class="hero is-fullheight-with-navbar">
+    <div class="hero-body">
+        <div class="container">
+            <div class="columns is-centered">
+                <div class="column is-5-tablet is-4-desktop is-3-widescreen">
+                    <div class="box auth-box">
+                        <div class="has-text-centered mb-5">
+                            <i class="fas fa-heart fa-3x has-text-primary"></i>
+                            <h1 class="title is-3 mt-3">Welcome Back!</h1>
+                            <p class="subtitle is-6">Login to continue your journey</p>
+                        </div>
+
+                        <form method="POST" action="{{ url_for('auth.login') }}">
+                            <!-- Username -->
+                            <div class="field">
+                                <label class="label">Username</label>
+                                <div class="control has-icons-left">
+                                    <input class="input" type="text" name="username"
+                                           placeholder="Enter your username"
+                                           value="{{ username or '' }}" required autofocus>
+                                    <span class="icon is-small is-left">
+                                        <i class="fas fa-user"></i>
+                                    </span>
+                                </div>
+                            </div>
+
+                            <!-- Password -->
+                            <div class="field">
+                                <label class="label">Password</label>
+                                <div class="control has-icons-left">
+                                    <input class="input" type="password" name="password"
+                                           placeholder="Enter your password" required>
+                                    <span class="icon is-small is-left">
+                                        <i class="fas fa-lock"></i>
+                                    </span>
+                                </div>
+                            </div>
+
+                            <!-- Remember Me -->
+                            <div class="field">
+                                <label class="checkbox">
+                                    <input type="checkbox" name="remember">
+                                    Remember me
+                                </label>
+                            </div>
+
+                            <!-- Submit Button -->
+                            <div class="field">
+                                <div class="control">
+                                    <button class="button is-primary is-fullwidth" type="submit">
+                                        <span class="icon">
+                                            <i class="fas fa-sign-in-alt"></i>
+                                        </span>
+                                        <span>Login</span>
+                                    </button>
+                                </div>
+                            </div>
+                        </form>
+
+                        <hr>
+
+                        <div class="has-text-centered">
+                            <p>Don't have an account?</p>
+                            <a href="{{ url_for('auth.register') }}" class="button is-link is-light mt-2">
+                                <span class="icon">
+                                    <i class="fas fa-user-plus"></i>
+                                </span>
+                                <span>Register Now</span>
+                            </a>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</section>
+{% endblock %}

templates/register.html

@@ -0,0 +1,101 @@
+{% extends "base.html" %}
+
+{% block title %}Register{% endblock %}
+
+{% block content %}
+<section class="hero is-fullheight-with-navbar">
+    <div class="hero-body">
+        <div class="container">
+            <div class="columns is-centered">
+                <div class="column is-5-tablet is-4-desktop is-3-widescreen">
+                    <div class="box auth-box">
+                        <div class="has-text-centered mb-5">
+                            <i class="fas fa-user-plus fa-3x has-text-link"></i>
+                            <h1 class="title is-3 mt-3">Join Us!</h1>
+                            <p class="subtitle is-6">Start your life coaching journey</p>
+                        </div>
+
+                        <form method="POST" action="{{ url_for('auth.register') }}">
+                            <!-- Username -->
+                            <div class="field">
+                                <label class="label">Username</label>
+                                <div class="control has-icons-left">
+                                    <input class="input" type="text" name="username"
+                                           placeholder="Choose a username"
+                                           value="{{ username or '' }}" required autofocus>
+                                    <span class="icon is-small is-left">
+                                        <i class="fas fa-user"></i>
+                                    </span>
+                                </div>
+                                <p class="help">At least 3 characters</p>
+                            </div>
+
+                            <!-- Email -->
+                            <div class="field">
+                                <label class="label">Email</label>
+                                <div class="control has-icons-left">
+                                    <input class="input" type="email" name="email"
+                                           placeholder="your.email@example.com"
+                                           value="{{ email or '' }}" required>
+                                    <span class="icon is-small is-left">
+                                        <i class="fas fa-envelope"></i>
+                                    </span>
+                                </div>
+                            </div>
+
+                            <!-- Password -->
+                            <div class="field">
+                                <label class="label">Password</label>
+                                <div class="control has-icons-left">
+                                    <input class="input" type="password" name="password"
+                                           placeholder="Create a strong password" required>
+                                    <span class="icon is-small is-left">
+                                        <i class="fas fa-lock"></i>
+                                    </span>
+                                </div>
+                                <p class="help">At least 6 characters</p>
+                            </div>
+
+                            <!-- Confirm Password -->
+                            <div class="field">
+                                <label class="label">Confirm Password</label>
+                                <div class="control has-icons-left">
+                                    <input class="input" type="password" name="password_confirm"
+                                           placeholder="Confirm your password" required>
+                                    <span class="icon is-small is-left">
+                                        <i class="fas fa-lock"></i>
+                                    </span>
+                                </div>
+                            </div>
+
+                            <!-- Submit Button -->
+                            <div class="field">
+                                <div class="control">
+                                    <button class="button is-link is-fullwidth" type="submit">
+                                        <span class="icon">
+                                            <i class="fas fa-user-plus"></i>
+                                        </span>
+                                        <span>Create Account</span>
+                                    </button>
+                                </div>
+                            </div>
+                        </form>
+
+                        <hr>
+
+                        <div class="has-text-centered">
+                            <p>Already have an account?</p>
+                            <a href="{{ url_for('auth.login') }}" class="button is-primary is-light mt-2">
+                                <span class="icon">
+                                    <i class="fas fa-sign-in-alt"></i>
+                                </span>
+                                <span>Login</span>
+                            </a>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</section>
+{% endblock %}