besm ellah

.dockerignore

@@ -0,0 +1,63 @@
+# Git
+.git
+.gitignore
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Logs
+*.log
+logs/
+
+# Local development
+.env
+.env.local
+.env.development
+.env.test
+.env.production
+
+# Test files
+tests/
+test_*.py
+
+# Documentation
+docs/
+*.md
+!README.md
+
+
+.cache/
+.pytest_cache/
+.mypy_cache/
+
+# Session data 
+session_data/
+session_summaries/
+vector_db/
+models/ 

.env

@@ -0,0 +1,26 @@
+# Model Configuration
+MODEL_NAME=meta-llama/Llama-3.2-3B-Instruct
+PEFT_MODEL_PATH=llama_fine_tuned
+GUIDELINES_PATH=guidelines.txt
+
+# API Configuration
+API_HOST=0.0.0.0
+API_PORT=8080
+DEBUG=False
+
+ALLOWED_ORIGINS=http://localhost:8000
+
+# Logging
+LOG_LEVEL=INFO
+LOG_FILE=mental_health_chatbot.log
+
+# Additional Configuration
+MAX_SESSION_DURATION=45  # in minutes
+MAX_MESSAGES_PER_SESSION=100000
+SESSION_TIMEOUT=44  # in minutes
+EMOTION_THRESHOLD=0.3  # minimum confidence for emotion detection
+
+
+
+
+PORT= 8000

.gitignore

@@ -0,0 +1 @@
+offload/

Dockerfile

@@ -0,0 +1,49 @@
+# Use Python 3.9 slim image
+FROM python:3.9-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create necessary directories and set permissions
+RUN mkdir -p /tmp/huggingface && \
+    chmod -R 777 /tmp/huggingface
+
+# Create a non-root user
+RUN useradd -m -s /bin/bash user && \
+    chown -R user:user /tmp/huggingface
+
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set working directory
+WORKDIR $HOME/app
+
+# Create app directories
+RUN mkdir -p $HOME/app/session_data $HOME/app/session_summaries $HOME/app/vector_db $HOME/app/models
+
+# Copy requirements first for better caching
+COPY --chown=user:user requirements.txt .
+RUN pip install --user --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY --chown=user:user . .
+
+# Make start.sh executable
+RUN chmod +x start.sh
+
+# Set environment variables
+ENV PORT=7860
+ENV TRANSFORMERS_CACHE=/tmp/huggingface
+ENV HF_HOME=/tmp/huggingface
+ENV TOKENIZERS_PARALLELISM=false
+ENV TRANSFORMERS_VERBOSITY=error
+ENV BITSANDBYTES_NOWELCOME=1
+
+# Expose the port
+EXPOSE 7860
+
+# Run the application using start.sh
+CMD ["./start.sh"]

app.py

@@ -0,0 +1,233 @@
+from fastapi import FastAPI, WebSocket, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+import os
+from dotenv import load_dotenv
+from chatbot import MentalHealthChatbot
+from datetime import datetime
+import json
+import uvicorn
+import torch
+
+# Load environment variables
+load_dotenv()
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Mental Health Chatbot",
+    description="mental health support chatbot",
+    version="1.0.0"
+)
+
+# Add CORS middleware - allow all origins for Hugging Face Spaces
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+# Initialize chatbot with Hugging Face Spaces specific settings
+chatbot = MentalHealthChatbot(
+    model_name="meta-llama/Llama-3.2-3B-Instruct",
+    peft_model_path="nada013/mental-health-chatbot",
+    use_4bit=True,  # Enable 4-bit quantization for GPU
+    device="cuda" if torch.cuda.is_available() else "cpu",  # Use GPU if available
+    therapy_guidelines_path="guidelines.txt" 
+)
+
+# Add GPU memory logging
+if torch.cuda.is_available():
+    logger.info(f"GPU Device: {torch.cuda.get_device_name(0)}")
+    logger.info(f"Available GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f}GB")
+
+# pydantic models
+class MessageRequest(BaseModel):
+    user_id: str
+    message: str
+
+class MessageResponse(BaseModel):
+    response: str
+    session_id: str
+
+class SessionSummary(BaseModel):
+    session_id: str
+    user_id: str
+    start_time: str
+    end_time: str
+    duration_minutes: float
+    current_phase: str
+    primary_emotions: List[str]
+    emotion_progression: List[str]
+    summary: str
+    recommendations: List[str]
+    session_characteristics: Dict[str, Any]
+
+class UserReply(BaseModel):
+    text: str
+    timestamp: str
+    session_id: str
+
+class Message(BaseModel):
+    text: str
+    role: str = "user"
+
+# API endpoints
+@app.get("/")
+async def root():
+    """Root endpoint with API information."""
+    return {
+        "name": "Mental Health Chatbot API",
+        "version": "1.0.0",
+        "description": "API for mental health support chatbot",
+        "endpoints": {
+            "POST /start_session": "Start a new chat session",
+            "POST /send_message": "Send a message to the chatbot",
+            "POST /end_session": "End the current session",
+            "GET /health": "Health check endpoint",
+            "GET /docs": "API documentation (Swagger UI)",
+            "GET /redoc": "API documentation (ReDoc)",
+            "GET /ws": "WebSocket endpoint"
+        }
+    }
+
+@app.post("/start_session", response_model=MessageResponse)
+async def start_session(user_id: str):
+    try:
+        session_id, initial_message = chatbot.start_session(user_id)
+        return MessageResponse(response=initial_message, session_id=session_id)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/send_message", response_model=MessageResponse)
+async def send_message(request: MessageRequest):
+    try:
+        response = chatbot.process_message(request.user_id, request.message)
+        session = chatbot.conversations[request.user_id]
+        return MessageResponse(response=response, session_id=session.session_id)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/end_session", response_model=SessionSummary)
+async def end_session(user_id: str):
+    try:
+        summary = chatbot.end_session(user_id)
+        if not summary:
+            raise HTTPException(status_code=404, detail="No active session found")
+        return summary
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
+@app.get("/session_summary/{session_id}", response_model=SessionSummary)
+async def get_session_summary(
+    session_id: str,
+    include_summary: bool = True,
+    include_recommendations: bool = True,
+    include_emotions: bool = True,
+    include_characteristics: bool = True,
+    include_duration: bool = True,
+    include_phase: bool = True
+):
+    try:
+        summary = chatbot.get_session_summary(session_id)
+        if not summary:
+            raise HTTPException(status_code=404, detail="Session summary not found")
+        
+        filtered_summary = {
+            "session_id": summary["session_id"],
+            "user_id": summary["user_id"],
+            "start_time": summary["start_time"],
+            "end_time": summary["end_time"],
+            "duration_minutes": summary.get("duration_minutes", 0.0),
+            "current_phase": summary.get("current_phase", "unknown"),
+            "primary_emotions": summary.get("primary_emotions", []),
+            "emotion_progression": summary.get("emotion_progression", []),
+            "summary": summary.get("summary", ""),
+            "recommendations": summary.get("recommendations", []),
+            "session_characteristics": summary.get("session_characteristics", {})
+        }
+        
+        # Filter out fields based on include parameters
+        if not include_summary:
+            filtered_summary["summary"] = ""
+        if not include_recommendations:
+            filtered_summary["recommendations"] = []
+        if not include_emotions:
+            filtered_summary["primary_emotions"] = []
+            filtered_summary["emotion_progression"] = []
+        if not include_characteristics:
+            filtered_summary["session_characteristics"] = {}
+        if not include_duration:
+            filtered_summary["duration_minutes"] = 0.0
+        if not include_phase:
+            filtered_summary["current_phase"] = "unknown"
+        
+        return filtered_summary
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/user_replies/{user_id}")
+async def get_user_replies(user_id: str):
+    try:
+        replies = chatbot.get_user_replies(user_id)
+        
+        # Create a filename with user_id and timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"user_replies_{user_id}_{timestamp}.json"
+        filepath = os.path.join("user_replies", filename)
+        
+        # Ensure directory exists
+        os.makedirs("user_replies", exist_ok=True)
+        
+        # Write replies to JSON file
+        with open(filepath, 'w') as f:
+            json.dump({
+                "user_id": user_id,
+                "timestamp": datetime.now().isoformat(),
+                "replies": replies
+            }, f, indent=2)
+        
+        # Return the file
+        return FileResponse(
+            path=filepath,
+            filename=filename,
+            media_type="application/json"
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    try:
+        while True:
+            data = await websocket.receive_json()
+            user_id = data.get("user_id")
+            message = data.get("message")
+            
+            if not user_id or not message:
+                await websocket.send_json({"error": "Missing user_id or message"})
+                continue
+                
+            response = chatbot.process_message(user_id, message)
+            session_id = chatbot.conversations[user_id].session_id
+            
+            await websocket.send_json({
+                "response": response,
+                "session_id": session_id
+            })
+    except Exception as e:
+        await websocket.send_json({"error": str(e)})
+    finally:
+        await websocket.close()
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port) 

chatbot.py

@@ -0,0 +1,907 @@
+import os
+import logging
+import json
+import torch
+import re
+from typing import List, Dict, Any, Optional, Union
+from datetime import datetime
+from pydantic import BaseModel, Field
+import tempfile
+
+# Model imports
+from transformers import (
+    pipeline, 
+    AutoTokenizer, 
+    AutoModelForCausalLM,
+    BitsAndBytesConfig
+)
+from peft import PeftModel, PeftConfig
+from sentence_transformers import SentenceTransformer
+
+# LangChain imports
+from langchain.llms import HuggingFacePipeline
+from langchain.chains import LLMChain
+from langchain.memory import ConversationBufferMemory
+from langchain.prompts import PromptTemplate
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.document_loaders import TextLoader
+from langchain.vectorstores import FAISS
+
+# Import FlowManager
+from conversation_flow import FlowManager
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+# Suppress warnings
+import warnings
+warnings.filterwarnings('ignore', category=UserWarning)
+
+# Set up cache directories
+def setup_cache_dirs():
+    # Check if running in Hugging Face Spaces
+    is_spaces = os.environ.get('SPACE_ID') is not None
+    
+    if is_spaces:
+        # Use /tmp for Hugging Face Spaces with proper permissions
+        cache_dir = '/tmp/huggingface'
+        os.environ.update({
+            'TRANSFORMERS_CACHE': cache_dir,
+            'HF_HOME': cache_dir,
+            'TOKENIZERS_PARALLELISM': 'false',
+            'TRANSFORMERS_VERBOSITY': 'error',
+            'BITSANDBYTES_NOWELCOME': '1',
+            'HF_DATASETS_CACHE': cache_dir,
+            'HF_METRICS_CACHE': cache_dir,
+            'HF_MODULES_CACHE': cache_dir,
+            'HUGGING_FACE_HUB_TOKEN': os.environ.get('HF_TOKEN', ''),
+            'HF_TOKEN': os.environ.get('HF_TOKEN', '')
+        })
+    else:
+        # Use default cache for local development
+        cache_dir = os.path.expanduser('~/.cache/huggingface')
+        os.environ.update({
+            'TOKENIZERS_PARALLELISM': 'false',
+            'TRANSFORMERS_VERBOSITY': 'error',
+            'BITSANDBYTES_NOWELCOME': '1'
+        })
+    
+    # Create cache directory if it doesn't exist
+    os.makedirs(cache_dir, exist_ok=True)
+    
+    return cache_dir
+
+# Set up cache directories
+CACHE_DIR = setup_cache_dirs()
+
+# Define base directory and paths
+BASE_DIR = os.path.abspath(os.path.dirname(__file__))
+MODELS_DIR = os.path.join(BASE_DIR, "models")
+VECTOR_DB_PATH = os.path.join(BASE_DIR, "vector_db")
+SESSION_DATA_PATH = os.path.join(BASE_DIR, "session_data")
+SUMMARIES_DIR = os.path.join(BASE_DIR, "session_summaries")
+
+# Create necessary directories
+for directory in [MODELS_DIR, VECTOR_DB_PATH, SESSION_DATA_PATH, SUMMARIES_DIR]:
+    os.makedirs(directory, exist_ok=True)
+
+# Pydantic models
+class Message(BaseModel):
+    text: str = Field(..., description="The content of the message")
+    timestamp: str = Field(None, description="ISO format timestamp of the message")
+    role: str = Field("user", description="The role of the message sender (user or assistant)")
+
+class SessionSummary(BaseModel):
+    session_id: str = Field(
+        ...,
+        description="Unique identifier for the session",
+        examples=["user_789_session_20240314"]
+    )
+    user_id: str = Field(
+        ...,
+        description="Identifier of the user",
+        examples=["user_123"]
+    )
+    start_time: str = Field(
+        ...,
+        description="ISO format start time of the session"
+    )
+    end_time: str = Field(
+        ...,
+        description="ISO format end time of the session"
+    )
+    message_count: int = Field(
+        ...,
+        description="Total number of messages in the session"
+    )
+    duration_minutes: float = Field(
+        ...,
+        description="Duration of the session in minutes"
+    )
+    primary_emotions: List[str] = Field(
+        ...,
+        min_items=1,
+        description="List of primary emotions detected",
+        examples=[
+            ["anxiety", "stress"],
+            ["joy", "excitement"],
+            ["sadness", "loneliness"]
+        ]
+    )
+    emotion_progression: List[Dict[str, float]] = Field(
+        ...,
+        description="Progression of emotions throughout the session",
+        examples=[
+            [
+                {"anxiety": 0.8, "stress": 0.6},
+                {"calm": 0.7, "anxiety": 0.3},
+                {"joy": 0.9, "calm": 0.8}
+            ]
+        ]
+    )
+    summary_text: str = Field(
+        ...,
+        description="Text summary of the session",
+        examples=[
+            "The session focused on managing work-related stress and developing coping strategies. The client showed improvement in recognizing stress triggers and implementing relaxation techniques.",
+            "Discussion centered around relationship challenges and self-esteem issues. The client expressed willingness to try new communication strategies."
+        ]
+    )
+    recommendations: Optional[List[str]] = Field(
+        None,
+        description="Optional recommendations based on the session"
+    )
+
+class Conversation(BaseModel):
+    user_id: str = Field(
+        ...,
+        description="Identifier of the user",
+        examples=["user_123"]
+    )
+    session_id: str = Field(
+        "",
+        description="Identifier of the current session"
+    )
+    start_time: str = Field(
+        "",
+        description="ISO format start time of the conversation"
+    )
+    messages: List[Message] = Field(
+        [],
+        description="List of messages in the conversation",
+        examples=[
+            [
+                Message(text="I'm feeling anxious", role="user"),
+                Message(text="I understand you're feeling anxious. Can you tell me more about what's causing this?", role="assistant")
+            ]
+        ]
+    )
+    emotion_history: List[Dict[str, float]] = Field(
+        [],
+        description="History of emotions detected",
+        examples=[
+            [
+                {"anxiety": 0.8, "stress": 0.6},
+                {"calm": 0.7, "anxiety": 0.3}
+            ]
+        ]
+    )
+    context: Dict[str, Any] = Field(
+        {},
+        description="Additional context for the conversation",
+        examples=[
+            {
+                "last_emotion": "anxiety",
+                "conversation_topic": "work stress",
+                "previous_sessions": 3
+            }
+        ]
+    )
+    is_active: bool = Field(
+        True,
+        description="Whether the conversation is currently active",
+        examples=[True, False]
+    )
+
+class MentalHealthChatbot:
+    def __init__(
+        self,
+        model_name: str = "meta-llama/Llama-3.2-3B-Instruct",
+        peft_model_path: str = "nada013/mental-health-chatbot", 
+        therapy_guidelines_path: str = None,
+        use_4bit: bool = True,
+        device: str = None
+    ):
+        # Set device (cuda if available, otherwise cpu)
+        if device is None:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        else:
+            self.device = device
+
+        # Set memory optimization for T4
+        if self.device == "cuda":
+            torch.cuda.empty_cache()  # Clear GPU cache
+            # Set smaller batch size for T4
+            self.batch_size = 4
+            # Enable memory efficient attention
+            os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128"
+        else:
+            self.batch_size = 8
+
+        logger.info(f"Using device: {self.device}")
+        
+        # Initialize models
+        self.peft_model_path = peft_model_path
+        
+        # Initialize emotion detection model
+        logger.info("Loading emotion detection model")
+        self.emotion_classifier = self._load_emotion_model()
+        
+        # Initialize LLAMA model
+        logger.info(f"Loading LLAMA model: {model_name}")
+        self.llama_model, self.llama_tokenizer, self.llm = self._initialize_llm(model_name, use_4bit)
+        
+        # Initialize summary model
+        logger.info("Loading summary model")
+        self.summary_model = pipeline(
+            "summarization",
+            model="philschmid/bart-large-cnn-samsum",
+            device=0 if self.device == "cuda" else -1,
+            model_kwargs={
+                "cache_dir": CACHE_DIR,
+                "torch_dtype": torch.float16,
+                "max_memory": {0: "2GB"} if self.device == "cuda" else None
+            }
+        )
+        logger.info("Summary model loaded successfully")
+        
+        # Initialize FlowManager
+        logger.info("Initializing FlowManager")
+        self.flow_manager = FlowManager(self.llm)
+        
+        # Setup conversation memory with LangChain
+        self.memory = ConversationBufferMemory(
+            return_messages=True,
+            input_key="input"
+        )
+        
+        # Create conversation prompt template
+        self.prompt_template = PromptTemplate(
+            input_variables=["history", "input", "past_context", "emotion_context", "guidelines"],
+            template="""You are a supportive and empathetic mental health conversational AI. Your role is to provide therapeutic support while maintaining professional boundaries.
+
+Previous conversation:
+{history}
+
+EMOTIONAL CONTEXT:
+{emotion_context}
+
+Past context: {past_context}
+
+Relevant therapeutic guidelines:
+{guidelines}
+
+Current message: {input}
+
+Provide a supportive response that:
+1. Validates the user's feelings without using casual greetings
+2. Asks relevant follow-up questions
+3. Maintains a conversational tone , professional and empathetic tone
+4. Focuses on understanding and support
+5. Avoids repeating previous responses
+
+Response:"""
+        )
+        
+        # Create the conversation chain
+        self.conversation = LLMChain(
+            llm=self.llm,
+            prompt=self.prompt_template,
+            memory=self.memory,
+            verbose=False
+        )
+        
+        # Setup embeddings for vector search
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-MiniLM-L6-v2"
+        )
+        
+        # Setup vector database for retrieving relevant past conversations
+        if therapy_guidelines_path and os.path.exists(therapy_guidelines_path):
+            self.setup_vector_db(therapy_guidelines_path)
+        else:
+            self.setup_vector_db(None)
+        
+        # Initialize conversation storage
+        self.conversations = {}
+        
+        # Load existing session summaries
+        self.session_summaries = {}
+        self._load_existing_summaries()
+        
+        logger.info("All models and components initialized successfully")
+        
+    def _load_emotion_model(self):
+        try:
+            # Load emotion model directly from Hugging Face
+            return pipeline(
+                "text-classification",
+                model="SamLowe/roberta-base-go_emotions",
+                top_k=None,
+                device_map="auto" if torch.cuda.is_available() else None,
+                model_kwargs={
+                    "cache_dir": CACHE_DIR,
+                    "torch_dtype": torch.float16,  # Use float16
+                    "max_memory": {0: "2GB"} if torch.cuda.is_available() else None  # Limit memory usage
+                },
+            )
+        except Exception as e:
+            logger.error(f"Error loading emotion model: {e}")
+            # Fallback to a simpler model
+            try:
+                return pipeline(
+                    "text-classification", 
+                    model="j-hartmann/emotion-english-distilroberta-base", 
+                    return_all_scores=True,
+                    device_map="auto" if torch.cuda.is_available() else None,
+                    model_kwargs={
+                        "cache_dir": CACHE_DIR,
+                        "torch_dtype": torch.float16,
+                        "max_memory": {0: "2GB"} if torch.cuda.is_available() else None
+                    },
+                )
+            except Exception as e:
+                logger.error(f"Error loading fallback emotion model: {e}")
+                # Return a simple pipeline that always returns neutral
+                return lambda text: [{"label": "neutral", "score": 1.0}]
+    
+    def _initialize_llm(self, model_name: str, use_4bit: bool):
+        try:
+            # Configure quantization only if CUDA is available
+            if use_4bit and torch.cuda.is_available():
+                quantization_config = BitsAndBytesConfig(
+                    load_in_4bit=True,
+                    bnb_4bit_compute_dtype=torch.float16,
+                    bnb_4bit_quant_type="nf4",
+                    bnb_4bit_use_double_quant=True,
+                )
+                
+                # Set max memory for T4 GPU
+                max_memory = {0: "14GB"}  # Leave 2GB buffer for other operations
+            else:
+                quantization_config = None
+                max_memory = None
+                logger.info("CUDA not available, running without quantization")
+
+            # Load base model
+            logger.info(f"Loading base model: {model_name}")
+            base_model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                quantization_config=quantization_config,
+                device_map="auto",
+                max_memory=max_memory,
+                trust_remote_code=True,
+                cache_dir=CACHE_DIR,
+                use_auth_token=os.environ.get('HF_TOKEN'),
+                torch_dtype=torch.float16  # Use float16 for better memory efficiency
+            )
+
+            # Load tokenizer
+            logger.info("Loading tokenizer")
+            tokenizer = AutoTokenizer.from_pretrained(
+                model_name,
+                cache_dir=CACHE_DIR,
+                use_auth_token=os.environ.get('HF_TOKEN')  # Add auth token for gated models
+            )
+            tokenizer.pad_token = tokenizer.eos_token
+
+            # Load PEFT model
+            logger.info(f"Loading PEFT model from {self.peft_model_path}")
+            model = PeftModel.from_pretrained(
+                base_model, 
+                self.peft_model_path,
+                cache_dir=CACHE_DIR,
+                use_auth_token=os.environ.get('HF_TOKEN')  # Add auth token for gated models
+            )
+            logger.info("Successfully loaded PEFT model")
+
+            # Create text generation pipeline
+            text_generator = pipeline(
+                "text-generation",
+                model=model,
+                tokenizer=tokenizer,
+                max_new_tokens=512,
+                temperature=0.7,
+                top_p=0.95,
+                repetition_penalty=1.1,
+                do_sample=True,
+                device_map="auto" if torch.cuda.is_available() else None
+            )
+            
+            # Create LangChain wrapper
+            llm = HuggingFacePipeline(pipeline=text_generator)
+            
+            return model, tokenizer, llm
+            
+        except Exception as e:
+            logger.error(f"Error initializing LLM: {str(e)}")
+            raise
+    
+    def setup_vector_db(self, guidelines_path: str = None):
+        
+        logger.info("Setting up FAISS vector database")
+        
+        # Check if vector DB exists
+        vector_db_exists = os.path.exists(os.path.join(VECTOR_DB_PATH, "index.faiss"))
+        
+        if not vector_db_exists:
+            # Load therapy guidelines 
+            if guidelines_path and os.path.exists(guidelines_path):
+                loader = TextLoader(guidelines_path)
+                documents = loader.load()
+                
+                # Split documents into chunks with better overlap for context
+                text_splitter = RecursiveCharacterTextSplitter(
+                    chunk_size=500,  # Smaller chunks for more precise retrieval
+                    chunk_overlap=100,
+                    separators=["\n\n", "\n", " ", ""]
+                )
+                chunks = text_splitter.split_documents(documents)
+                
+                # Create and save the vector store
+                self.vector_db = FAISS.from_documents(chunks, self.embeddings)
+                self.vector_db.save_local(VECTOR_DB_PATH)
+                logger.info("Successfully loaded and indexed therapy guidelines")
+            else:
+                # Initialize with empty vector DB
+                self.vector_db = FAISS.from_texts(["Initial empty vector store"], self.embeddings)
+                self.vector_db.save_local(VECTOR_DB_PATH)
+                logger.warning("No guidelines file provided, using empty vector store")
+        else:
+            # Load existing vector DB
+            self.vector_db = FAISS.load_local(VECTOR_DB_PATH, self.embeddings, allow_dangerous_deserialization=True)
+            logger.info("Loaded existing vector database")
+    
+    def _load_existing_summaries(self):
+        if not os.path.exists(SUMMARIES_DIR):
+            return
+            
+        for filename in os.listdir(SUMMARIES_DIR):
+            if filename.endswith('.json'):
+                try:
+                    with open(os.path.join(SUMMARIES_DIR, filename), 'r') as f:
+                        summary_data = json.load(f)
+                        session_id = summary_data.get('session_id')
+                        if session_id:
+                            self.session_summaries[session_id] = summary_data
+                except Exception as e:
+                    logger.warning(f"Failed to load summary from {filename}: {e}")
+
+    def detect_emotion(self, text: str) -> Dict[str, float]:
+        try:
+            results = self.emotion_classifier(text)[0]
+            return {result['label']: result['score'] for result in results}
+        except Exception as e:
+            logger.error(f"Error detecting emotions: {e}")
+            return {"neutral": 1.0}
+
+    def retrieve_relevant_context(self, query: str, k: int = 3) -> str:
+        # Retrieve relevant past conversations using vector similarity
+        if not hasattr(self, 'vector_db'):
+            return ""
+        
+        try:
+            # Retrieve similar documents from vector DB
+            docs = self.vector_db.similarity_search(query, k=k)
+            
+            # Combine the content of retrieved documents
+            relevant_context = "\n".join([doc.page_content for doc in docs])
+            return relevant_context
+        except Exception as e:
+            logger.error(f"Error retrieving context: {e}")
+            return ""
+
+    def retrieve_relevant_guidelines(self, query: str, emotion_context: str) -> str:
+        if not hasattr(self, 'vector_db'):
+            return ""
+        
+        try:
+            # Combine query and emotion context for better relevance
+            search_query = f"{query} {emotion_context}"
+            
+            # Retrieve similar documents from vector DB
+            docs = self.vector_db.similarity_search(search_query, k=2)
+            
+            # Combine the content of retrieved documents
+            relevant_guidelines = "\n".join([doc.page_content for doc in docs])
+            return relevant_guidelines
+        except Exception as e:
+            logger.error(f"Error retrieving guidelines: {e}")
+            return ""
+
+    def generate_response(self, prompt: str, emotion_data: Dict[str, float], conversation_history: List[Dict]) -> str:
+        
+        # Get primary and secondary emotions
+        sorted_emotions = sorted(emotion_data.items(), key=lambda x: x[1], reverse=True)
+        primary_emotion = sorted_emotions[0][0] if sorted_emotions else "neutral"
+        
+        # Get secondary emotions (if any)
+        secondary_emotions = []
+        for emotion, score in sorted_emotions[1:3]:  # Get 2nd and 3rd strongest emotions
+            if score > 0.2:  # Only include if reasonably strong
+                secondary_emotions.append(emotion)
+        
+        # Create emotion context string
+        emotion_context = f"User is primarily feeling {primary_emotion}"
+        if secondary_emotions:
+            emotion_context += f" with elements of {' and '.join(secondary_emotions)}"
+        emotion_context += "."
+        
+        # Retrieve relevant guidelines
+        guidelines = self.retrieve_relevant_guidelines(prompt, emotion_context)
+        
+        # Retrieve past context
+        past_context = self.retrieve_relevant_context(prompt)
+        
+        # Generate response using the conversation chain
+        response = self.conversation.predict(
+            input=prompt,
+            past_context=past_context,
+            emotion_context=emotion_context,
+            guidelines=guidelines
+        )
+        
+        # Clean up the response to only include the actual message
+        response = response.split("Response:")[-1].strip()
+        response = response.split("---")[0].strip()
+        response = response.split("Note:")[0].strip()
+        
+        # Remove any casual greetings like "Hey" or "Hi"
+        response = re.sub(r'^(Hey|Hi|Hello|Hi there|Hey there),\s*', '', response)
+        
+        # Ensure the response is unique and not repeating previous messages
+        if len(conversation_history) > 0:
+            last_responses = [msg["text"] for msg in conversation_history[-4:] if msg["role"] == "assistant"]
+            if response in last_responses:
+                # Generate a new response with a different angle
+                response = self.conversation.predict(
+                    input=f"{prompt} (Please provide a different perspective)",
+                    past_context=past_context,
+                    emotion_context=emotion_context,
+                    guidelines=guidelines
+                )
+                response = response.split("Response:")[-1].strip()
+                response = re.sub(r'^(Hey|Hi|Hello|Hi there|Hey there),\s*', '', response)
+        
+        return response.strip()
+
+    def generate_session_summary(
+        self,
+        flow_manager_session: Dict = None
+    ) -> Dict:
+        
+        if not flow_manager_session:
+            return {
+                "session_id": "",
+                "user_id": "",
+                "start_time": "",
+                "end_time": datetime.now().isoformat(),
+                "duration_minutes": 0,
+                "current_phase": "unknown",
+                "primary_emotions": [],
+                "emotion_progression": [],
+                "summary": "Error: No session data provided",
+                "recommendations": ["Unable to generate recommendations"],
+                "session_characteristics": {}
+            }
+            
+        # Get session data from FlowManager
+        session_id = flow_manager_session.get('session_id', '')
+        user_id = flow_manager_session.get('user_id', '')
+        current_phase = flow_manager_session.get('current_phase')
+        
+        if current_phase:
+            # Convert ConversationPhase to dict
+            current_phase = {
+                'name': current_phase.name,
+                'description': current_phase.description,
+                'goals': current_phase.goals,
+                'started_at': current_phase.started_at,
+                'ended_at': current_phase.ended_at,
+                'completion_metrics': current_phase.completion_metrics
+            }
+        
+        session_start = flow_manager_session.get('started_at')
+        if isinstance(session_start, str):
+            session_start = datetime.fromisoformat(session_start)
+        session_duration = (datetime.now() - session_start).total_seconds() / 60 if session_start else 0
+        
+        # Get emotion progression and primary emotions
+        emotion_progression = flow_manager_session.get('emotion_progression', [])
+        emotion_history = flow_manager_session.get('emotion_history', [])
+        
+        # Extract primary emotions from emotion history
+        primary_emotions = []
+        if emotion_history:
+            # Get the most frequent emotions
+            emotion_counts = {}
+            for entry in emotion_history:
+                emotions = entry.get('emotions', {})
+                if isinstance(emotions, dict):
+                    primary = max(emotions.items(), key=lambda x: x[1])[0]
+                    emotion_counts[primary] = emotion_counts.get(primary, 0) + 1
+            
+            # sort by frequency and get top 3
+            primary_emotions = sorted(emotion_counts.items(), key=lambda x: x[1], reverse=True)[:3]
+            primary_emotions = [emotion for emotion, _ in primary_emotions]
+        
+        # get session 
+        session_characteristics = flow_manager_session.get('llm_context', {}).get('session_characteristics', {})
+        
+        # prepare the text for summarization
+        summary_text = f"""
+        Session Overview:
+        - Session ID: {session_id}
+        - User ID: {user_id}
+        - Phase: {current_phase.get('name', 'unknown') if current_phase else 'unknown'}
+        - Duration: {session_duration:.1f} minutes
+        
+        Emotional Analysis:
+        - Primary Emotions: {', '.join(primary_emotions) if primary_emotions else 'No primary emotions detected'}
+        - Emotion Progression: {', '.join(emotion_progression) if emotion_progression else 'No significant emotion changes noted'}
+        
+        Session Characteristics:
+        - Therapeutic Alliance: {session_characteristics.get('alliance_strength', 'N/A')}
+        - Engagement Level: {session_characteristics.get('engagement_level', 'N/A')}
+        - Emotional Pattern: {session_characteristics.get('emotional_pattern', 'N/A')}
+        - Cognitive Pattern: {session_characteristics.get('cognitive_pattern', 'N/A')}
+        
+        Key Observations:
+        - The session focused on {current_phase.get('description', 'general discussion') if current_phase else 'general discussion'}
+        - Main emotional themes: {', '.join(primary_emotions) if primary_emotions else 'not identified'}
+        - Session progress: {session_characteristics.get('progress_quality', 'N/A')}
+        """
+        
+        # Generate summary using BART
+        summary = self.summary_model(
+            summary_text,
+            max_length=150,
+            min_length=50,
+            do_sample=False
+        )[0]['summary_text']
+        
+        # Generate recommendations using Llama
+        recommendations_prompt = f"""
+        Based on the following session summary, provide 2-3 specific recommendations for follow-up:
+        
+        {summary}
+        
+        Session Characteristics:
+        - Therapeutic Alliance: {session_characteristics.get('alliance_strength', 'N/A')}
+        - Engagement Level: {session_characteristics.get('engagement_level', 'N/A')}
+        - Emotional Pattern: {session_characteristics.get('emotional_pattern', 'N/A')}
+        - Cognitive Pattern: {session_characteristics.get('cognitive_pattern', 'N/A')}
+        
+        Recommendations should be:
+        1. Actionable and specific
+        2. Based on the session content
+        3. Focused on next steps
+        """
+        
+        recommendations = self.llm.invoke(recommendations_prompt)
+        
+       
+        recommendations = recommendations.split('\n')
+        recommendations = [r.strip() for r in recommendations if r.strip()]
+        recommendations = [r for r in recommendations if not r.startswith(('Based on', 'Session', 'Recommendations'))]
+        
+        
+        return {
+            "session_id": session_id,
+            "user_id": user_id,
+            "start_time": session_start.isoformat() if isinstance(session_start, datetime) else str(session_start),
+            "end_time": datetime.now().isoformat(),
+            "duration_minutes": session_duration,
+            "current_phase": current_phase.get('name', 'unknown') if current_phase else 'unknown',
+            "primary_emotions": primary_emotions,
+            "emotion_progression": emotion_progression,
+            "summary": summary,
+            "recommendations": recommendations,
+            "session_characteristics": session_characteristics
+        }
+
+    def start_session(self, user_id: str) -> tuple[str, str]:
+        # Generate session id
+        session_id = f"{user_id}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+        
+        # Initialize FlowManager session
+        self.flow_manager.initialize_session(user_id)
+        
+        # Create a new conversation
+        self.conversations[user_id] = Conversation(
+            user_id=user_id,
+            session_id=session_id,
+            start_time=datetime.now().isoformat(),
+            is_active=True
+        )
+        
+        # Clear conversation memory
+        self.memory.clear()
+        
+        # Generate initial greeting and question
+        initial_message = """Hello! I'm here to support you today. How have you been feeling lately?"""
+        
+        # Add the initial message to conversation history
+        assistant_message = Message(
+            text=initial_message,
+            timestamp=datetime.now().isoformat(),
+            role="assistant"
+        )
+        self.conversations[user_id].messages.append(assistant_message)
+        
+        logger.info(f"Session started for user {user_id}")
+        return session_id, initial_message
+
+    def end_session(
+        self, 
+        user_id: str, 
+        flow_manager: Optional[Any] = None
+    ) -> Optional[Dict]:
+
+        if user_id not in self.conversations or not self.conversations[user_id].is_active:
+            return None
+        
+        conversation = self.conversations[user_id]
+        conversation.is_active = False
+        
+        # Get FlowManager session data
+        flow_manager_session = self.flow_manager.user_sessions.get(user_id)
+        
+        # Generate session summary
+        try:
+            session_summary = self.generate_session_summary(flow_manager_session)
+            
+            # Save summary to disk
+            summary_path = os.path.join(SUMMARIES_DIR, f"{session_summary['session_id']}.json")
+            with open(summary_path, 'w') as f:
+                json.dump(session_summary, f, indent=2)
+            
+            # Store in memory
+            self.session_summaries[session_summary['session_id']] = session_summary
+            
+            # Clear conversation memory
+            self.memory.clear()
+            
+            return session_summary
+        except Exception as e:
+            logger.error(f"Failed to generate session summary: {e}")
+            return None
+
+    def process_message(self, user_id: str, message: str) -> str:
+        
+        # Check for risk flags 
+        risk_keywords = ["suicide", "kill myself", "end my life", "self-harm", "hurt myself"]
+        risk_detected = any(keyword in message.lower() for keyword in risk_keywords)
+        
+        # Create or get conversation
+        if user_id not in self.conversations or not self.conversations[user_id].is_active:
+            self.start_session(user_id)
+        
+        conversation = self.conversations[user_id]
+        
+        #  user message -> conversation history
+        new_message = Message(
+            text=message,
+            timestamp=datetime.now().isoformat(),
+            role="user"
+        )
+        conversation.messages.append(new_message)
+        
+        # For crisis 
+        if risk_detected:
+            logger.warning(f"Risk flag detected in session {user_id}")
+            
+            crisis_response = """ I'm really sorry you're feeling this way — it sounds incredibly heavy, and I want you to know that you're not alone.
+
+You don't have to face this by yourself. Our app has licensed mental health professionals who are ready to support you. I can connect you right now if you'd like.
+
+In the meantime, I'm here to listen and talk with you. You can also do grounding exercises or calming techniques with me if you prefer. Just say "help me calm down" or "I need a break."
+
+Would you like to connect with a professional now, or would you prefer to keep talking with me for a bit? Either way, I'm here for you."""
+            
+            #  assistant response -> conversation history
+            assistant_message = Message(
+                text=crisis_response,
+                timestamp=datetime.now().isoformat(),
+                role="assistant"
+            )
+            conversation.messages.append(assistant_message)
+            
+            return crisis_response
+        
+        # Detect emotions
+        emotions = self.detect_emotion(message)
+        conversation.emotion_history.append(emotions)
+        
+        # Process message with FlowManager
+        flow_context = self.flow_manager.process_message(user_id, message, emotions)
+        
+        # Format conversation history 
+        conversation_history = []
+        for msg in conversation.messages:
+            conversation_history.append({
+                "text": msg.text,
+                "timestamp": msg.timestamp,
+                "role": msg.role
+            })
+        
+        # Generate response
+        response_text = self.generate_response(message, emotions, conversation_history)
+        
+        # Generate a follow-up question if the response is too short
+        if len(response_text.split()) < 20 and not response_text.endswith('?'):
+            follow_up_prompt = f"""Based on the conversation so far:
+{chr(10).join([f"{msg['role']}: {msg['text']}" for msg in conversation_history[-3:]])}
+
+Generate a thoughtful follow-up question that:
+1. Shows you're actively listening
+2. Encourages deeper exploration
+3. Maintains therapeutic rapport
+4. Is open-ended and non-judgmental
+
+Respond with just the question."""
+            
+            follow_up = self.llm.invoke(follow_up_prompt)
+            response_text += f"\n\n{follow_up}"
+        
+        #  assistant response -> conversation history
+        assistant_message = Message(
+            text=response_text,
+            timestamp=datetime.now().isoformat(),
+            role="assistant"
+        )
+        conversation.messages.append(assistant_message)
+        
+        # Update context
+        conversation.context.update({
+            "last_emotion": emotions,
+            "last_interaction": datetime.now().isoformat(),
+            "flow_context": flow_context
+        })
+        
+        # Store this interaction in vector database
+        current_interaction = f"User: {message}\nChatbot: {response_text}"
+        self.vector_db.add_texts([current_interaction])
+        self.vector_db.save_local(VECTOR_DB_PATH)
+        
+        return response_text
+
+    def get_session_summary(self, session_id: str) -> Optional[Dict[str, Any]]:
+        
+        return self.session_summaries.get(session_id)
+
+    def get_user_replies(self, user_id: str) -> List[Dict[str, Any]]:
+        if user_id not in self.conversations:
+            return []
+            
+        conversation = self.conversations[user_id]
+        user_replies = []
+        
+        for message in conversation.messages:
+            if message.role == "user":
+                user_replies.append({
+                    "text": message.text,
+                    "timestamp": message.timestamp,
+                    "session_id": conversation.session_id
+                })
+                
+        return user_replies
+
+if __name__ == "__main__":
+    pass

conversation_flow.py

@@ -0,0 +1,467 @@
+import logging
+import json
+import json5
+import time
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel, Field
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class PhaseTransitionResponse(BaseModel):
+    goals_progress: Dict[str, float]
+    should_transition: bool
+    next_phase: str
+    reasoning: str
+
+class SessionCharacteristics(BaseModel):
+    alliance_strength: float = Field(ge=0.0, le=1.0)
+    engagement_level: float = Field(ge=0.0, le=1.0)
+    emotional_pattern: str
+    cognitive_pattern: str
+    coping_mechanisms: List[str] = Field(min_items=2)
+    progress_quality: float = Field(ge=0.0, le=1.0)
+    recommended_focus: str
+
+class ConversationPhase(BaseModel):
+    name: str
+    description: str
+    goals: List[str]
+    typical_duration: int  # in minutes
+    started_at: Optional[str] = None  # ISO timestamp
+    ended_at: Optional[str] = None  # ISO timestamp
+    completion_metrics: Dict[str, float] = Field(default_factory=dict)  # e.g., {'goal_progress': 0.8}
+
+class FlowManager:
+    
+    # Define conversation phases 
+    PHASES = {
+        'introduction': {
+            'description': 'Establishing rapport and identifying main concerns',
+            'goals': [
+                'build therapeutic alliance',
+                'identify primary concerns',
+                'understand client expectations',
+                'establish session structure'
+            ],
+            'typical_duration': 5  # In mins
+        },
+        'exploration': {
+            'description': 'In-depth exploration of issues and their context',
+            'goals': [
+                'examine emotional responses',
+                'explore thought patterns',
+                'identify behavioral patterns',
+                'understand situational context',
+                'recognize relationship dynamics'
+            ],
+            'typical_duration': 15  # In mins
+        },
+        'intervention': {
+            'description': 'Providing strategies, insights, and therapeutic interventions',
+            'goals': [
+                'introduce coping techniques',
+                'reframe negative thinking',
+                'provide emotional validation',
+                'offer perspective shifts',
+                'suggest behavioral modifications'
+            ],
+            'typical_duration': 20  # In minutes
+        },
+        'conclusion': {
+            'description': 'Summarizing insights and establishing next steps',
+            'goals': [
+                'review key insights',
+                'consolidate learning',
+                'identify action items',
+                'set intentions',
+                'provide closure'
+            ],
+            'typical_duration': 5  # In minutes
+        }
+    }
+    
+    def __init__(self, llm, session_duration: int = 45):
+       
+        self.llm = llm
+        self.session_duration = session_duration * 60  # Convert to seconds
+        
+        # User session data structures
+        self.user_sessions = {}  # user_id -> session data
+        
+        logger.info(f"Initialized FlowManager with {session_duration} minute sessions")
+    
+    def _ensure_user_session(self, user_id: str):
+        
+        if user_id not in self.user_sessions:
+            self.initialize_session(user_id)
+    
+    def initialize_session(self, user_id: str):
+        
+        now = datetime.now().isoformat()
+        
+        # Create initial phase
+        initial_phase = ConversationPhase(
+            name='introduction',
+            description=self.PHASES['introduction']['description'],
+            goals=self.PHASES['introduction']['goals'],
+            typical_duration=self.PHASES['introduction']['typical_duration'],
+            started_at=now
+        )
+        
+        # Generate session ID
+        session_id = f"{user_id}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+        
+        # Initialize session data
+        self.user_sessions[user_id] = {
+            'session_id': session_id,
+            'user_id': user_id,
+            'started_at': now,
+            'updated_at': now,
+            'current_phase': initial_phase,
+            'phase_history': [initial_phase],
+            'message_count': 0,
+            'emotion_history': [],
+            'emotion_progression': [],
+            'flags': {
+                'crisis_detected': False,
+                'long_silences': False
+            },
+            'llm_context': {
+                'session_characteristics': {}
+            }
+        }
+        
+        logger.info(f"Initialized new session for user {user_id}")
+        return self.user_sessions[user_id]
+    
+    def process_message(self, user_id: str, message: str, emotions: Dict[str, float]) -> Dict[str, Any]:
+
+        self._ensure_user_session(user_id)
+        session = self.user_sessions[user_id]
+        
+        # Update session
+        now = datetime.now().isoformat()
+        session['updated_at'] = now
+        session['message_count'] += 1
+        
+        # Track emotions
+        emotion_entry = {
+            'timestamp': now,
+            'emotions': emotions,
+            'message_idx': session['message_count']
+        }
+        session['emotion_history'].append(emotion_entry)
+        
+        # Update emotion progression
+        if not session.get('emotion_progression'):
+            session['emotion_progression'] = []
+        
+        # Get primary emotion (highest confidence)
+        primary_emotion = max(emotions.items(), key=lambda x: x[1])[0]
+        session['emotion_progression'].append(primary_emotion)
+        
+        # Check for phase transition
+        self._check_phase_transition(user_id, message, emotions)
+        
+        # Update session characteristics via LLM analysis (periodically)
+        if session['message_count'] % 5 == 0:
+            self._update_session_characteristics(user_id)
+        
+        # Create flow context for response generation
+        flow_context = self._create_flow_context(user_id)
+        
+        return flow_context
+    
+    def _check_phase_transition(self, user_id: str, message: str, emotions: Dict[str, float]):
+       
+        session = self.user_sessions[user_id]
+        current_phase = session['current_phase']
+        
+        # Calculate session progress
+        started_at = datetime.fromisoformat(session['started_at'])
+        now = datetime.now()
+        elapsed_seconds = (now - started_at).total_seconds()
+        session_progress = elapsed_seconds / self.session_duration
+        
+        # Create prompt for LLM to evaluate phase transition
+        phase_context = {
+            'current': current_phase.name,
+            'description': current_phase.description,
+            'goals': current_phase.goals,
+            'time_in_phase': (now - datetime.fromisoformat(current_phase.started_at)).total_seconds() / 60,
+            'session_progress': session_progress,
+            'message_count': session['message_count']
+        }
+        
+        # Only check for transition if we've spent some time in current phase
+        min_time_in_phase_minutes = max(2, current_phase.typical_duration * 0.5)
+        if phase_context['time_in_phase'] < min_time_in_phase_minutes:
+            return
+            
+        prompt = f"""
+        Evaluate whether this therapeutic conversation should transition to the next phase.
+        
+        Current conversation state:
+        - Current phase: {current_phase.name} ("{current_phase.description}")
+        - Goals for this phase: {', '.join(current_phase.goals)}
+        - Time spent in this phase: {phase_context['time_in_phase']:.1f} minutes
+        - Session progress: {session_progress * 100:.1f}% complete
+        - Message count: {session['message_count']}
+        
+        Latest message from user: "{message}"
+        
+        Current emotions: {', '.join([f"{e} ({score:.2f})" for e, score in 
+                          sorted(emotions.items(), key=lambda x: x[1], reverse=True)[:3]])}
+        
+        Phases in a therapeutic conversation:
+        1. introduction: {self.PHASES['introduction']['description']}
+        2. exploration: {self.PHASES['exploration']['description']}
+        3. intervention: {self.PHASES['intervention']['description']}
+        4. conclusion: {self.PHASES['conclusion']['description']}
+        
+        Consider:
+        1. Have the goals of the current phase been sufficiently addressed?
+        2. Is the timing appropriate considering overall session progress?
+        3. Is there a natural transition point in the conversation?
+        4. Does the emotional content suggest readiness to move forward?
+        
+        First, provide your analysis of whether the key goals of the current phase have been met.
+        Then decide if the conversation should transition to the next phase.
+        
+        Respond with a JSON object in this format:
+        {{
+          "goals_progress": {{
+            "goal1": 0.5,
+            "goal2": 0.7
+          }},
+          "should_transition": false,
+          "next_phase": "exploration",
+          "reasoning": "brief explanation"
+        }}
+        
+        Output ONLY valid JSON without additional text.
+        """
+        
+        response = self.llm.invoke(prompt)
+        
+        try:
+            # Parse with json5 for more tolerant parsing
+            evaluation = json5.loads(response)
+            # Validate with Pydantic
+            phase_transition = PhaseTransitionResponse.parse_obj(evaluation)
+            
+            # Update goal progress metrics
+            for goal, score in phase_transition.goals_progress.items():
+                if goal in current_phase.goals:
+                    current_phase.completion_metrics[goal] = score
+            
+            # Check if we should transition
+            if phase_transition.should_transition:
+                if phase_transition.next_phase in self.PHASES:
+                    self._transition_to_phase(user_id, phase_transition.next_phase, phase_transition.reasoning)
+        except (json5.Json5DecodeError, ValueError):
+            self._check_time_based_transition(user_id)
+    
+    def _check_time_based_transition(self, user_id: str):
+        
+        session = self.user_sessions[user_id]
+        current_phase = session['current_phase']
+        
+        # Get elapsed time
+        started_at = datetime.fromisoformat(session['started_at'])
+        now = datetime.now()
+        elapsed_minutes = (now - started_at).total_seconds() / 60
+        
+        # Calculate phase thresholds
+        intro_threshold = self.PHASES['introduction']['typical_duration']
+        explore_threshold = intro_threshold + self.PHASES['exploration']['typical_duration']
+        intervention_threshold = explore_threshold + self.PHASES['intervention']['typical_duration']
+        
+        # Transition based on time
+        next_phase = None
+        if current_phase.name == 'introduction' and elapsed_minutes >= intro_threshold:
+            next_phase = 'exploration'
+        elif current_phase.name == 'exploration' and elapsed_minutes >= explore_threshold:
+            next_phase = 'intervention'
+        elif current_phase.name == 'intervention' and elapsed_minutes >= intervention_threshold:
+            next_phase = 'conclusion'
+            
+        if next_phase:
+            self._transition_to_phase(user_id, next_phase, "Time-based transition")
+    
+    def _transition_to_phase(self, user_id: str, next_phase_name: str, reason: str):
+       
+        session = self.user_sessions[user_id]
+        current_phase = session['current_phase']
+        
+        # End current phase
+        now = datetime.now().isoformat()
+        current_phase.ended_at = now
+        
+        # Create new phase
+        new_phase = ConversationPhase(
+            name=next_phase_name,
+            description=self.PHASES[next_phase_name]['description'],
+            goals=self.PHASES[next_phase_name]['goals'],
+            typical_duration=self.PHASES[next_phase_name]['typical_duration'],
+            started_at=now
+        )
+        
+        # Update session
+        session['current_phase'] = new_phase
+        session['phase_history'].append(new_phase)
+        
+        logger.info(f"User {user_id} transitioned from {current_phase.name} to {next_phase_name}: {reason}")
+    
+    def _update_session_characteristics(self, user_id: str):
+        session = self.user_sessions[user_id]
+        
+        # Only do this periodically to save LLM calls
+        if session['message_count'] < 5:
+            return
+            
+        # Create a summary of the conversation so far
+        message_sample = []
+        emotion_summary = {}
+        
+        # Get recent messages
+        for i, emotion_data in enumerate(session['emotion_history'][-10:]):
+            msg_idx = emotion_data['message_idx']
+            if i % 2 == 0:  # Just include a subset of messages
+                message_sample.append(f"Message {msg_idx}: User emotions: {', '.join([f'{e}({s:.2f})' for e, s in sorted(emotion_data['emotions'].items(), key=lambda x: x[1], reverse=True)[:2]])}")
+            
+            # Aggregate emotions
+            for emotion, score in emotion_data['emotions'].items():
+                if score > 0.3:
+                    emotion_summary[emotion] = emotion_summary.get(emotion, 0) + score
+                    
+        # Normalize emotion summary
+        if emotion_summary:
+            total = sum(emotion_summary.values())
+            emotion_summary = {e: s/total for e, s in emotion_summary.items()}
+            
+        #  prompt for LLM
+        prompt = f"""
+        Analyze this therapy session and provide a JSON response with the following characteristics:
+        
+        Current session state:
+        - Phase: {session['current_phase'].name} ({session['current_phase'].description})
+        - Message count: {session['message_count']}
+        - Emotion summary: {', '.join([f'{e}({s:.2f})' for e, s in sorted(emotion_summary.items(), key=lambda x: x[1], reverse=True)])}
+        
+        Recent messages:
+        {chr(10).join(message_sample)}
+        
+        Required JSON format:
+        {{
+          "alliance_strength": 0.8,
+          "engagement_level": 0.7,
+          "emotional_pattern": "brief description of emotional pattern",
+          "cognitive_pattern": "brief description of cognitive pattern",
+          "coping_mechanisms": ["mechanism1", "mechanism2"],
+          "progress_quality": 0.6,
+          "recommended_focus": "brief therapeutic recommendation"
+        }}
+        
+        Important:
+        1. Respond with ONLY the JSON object
+        2. Use numbers between 0.0 and 1.0 for alliance_strength, engagement_level, and progress_quality
+        3. Keep descriptions brief and focused
+        4. Include at least 2 coping mechanisms
+        5. Provide a specific recommended focus
+        
+        JSON Response:
+        """
+        
+        response = self.llm.invoke(prompt)
+        
+        try:
+            # Parse with json5 for more tolerant parsing
+            characteristics = json5.loads(response)
+            # Validate with Pydantic
+            session_chars = SessionCharacteristics.parse_obj(characteristics)
+            session['llm_context']['session_characteristics'] = session_chars.dict()
+            logger.info(f"Updated session characteristics for user {user_id}")
+        except (json5.Json5DecodeError, ValueError) as e:
+            logger.warning(f"Failed to parse session characteristics: {e}")
+    
+    def _create_flow_context(self, user_id: str) -> Dict[str, Any]:
+        
+        session = self.user_sessions[user_id]
+        current_phase = session['current_phase']
+        
+        # Calculate session times
+        started_at = datetime.fromisoformat(session['started_at'])
+        now = datetime.now()
+        elapsed_seconds = (now - started_at).total_seconds()
+        remaining_seconds = max(0, self.session_duration - elapsed_seconds)
+        
+        # Get primary emotions
+        emotions_summary = {}
+        for emotion_data in session['emotion_history'][-3:]:  # Last 3 messages
+            for emotion, score in emotion_data['emotions'].items():
+                emotions_summary[emotion] = emotions_summary.get(emotion, 0) + score
+                
+        if emotions_summary:
+            primary_emotions = sorted(emotions_summary.items(), key=lambda x: x[1], reverse=True)[:3]
+        else:
+            primary_emotions = []
+        
+        # Create guidance based on phase
+        phase_guidance = []
+        
+        # Add phase-specific guidance
+        if current_phase.name == 'introduction':
+            phase_guidance.append("Build rapport and identify main concerns")
+            if session['message_count'] > 3:
+                phase_guidance.append("Begin exploring emotional context")
+                
+        elif current_phase.name == 'exploration':
+            phase_guidance.append("Deepen understanding of issues and contexts")
+            phase_guidance.append("Connect emotional patterns to identify themes")
+                
+        elif current_phase.name == 'intervention':
+            phase_guidance.append("Offer support strategies and therapeutic insights")
+            if remaining_seconds < 600:  # Less than 10 minutes left
+                phase_guidance.append("Begin consolidating key insights")
+                
+        elif current_phase.name == 'conclusion':
+            phase_guidance.append("Summarize insights and establish next steps")
+            phase_guidance.append("Provide closure while maintaining supportive presence")
+        
+        # Add guidance based on session characteristics
+        if 'session_characteristics' in session['llm_context']:
+            char = session['llm_context']['session_characteristics']
+            
+            # Low alliance strength
+            if char.get('alliance_strength', 0.8) < 0.6:
+                phase_guidance.append("Focus on strengthening therapeutic alliance")
+                
+            # Low engagement
+            if char.get('engagement_level', 0.8) < 0.6:
+                phase_guidance.append("Increase engagement with more personalized responses")
+                
+            # Add recommended focus if available
+            if 'recommended_focus' in char:
+                phase_guidance.append(char['recommended_focus'])
+        
+        # Create flow context
+        flow_context = {
+            'phase': {
+                'name': current_phase.name,
+                'description': current_phase.description,
+                'goals': current_phase.goals
+            },
+            'session': {
+                'elapsed_minutes': elapsed_seconds / 60,
+                'remaining_minutes': remaining_seconds / 60,
+                'progress_percentage': (elapsed_seconds / self.session_duration) * 100,
+                'message_count': session['message_count']
+            },
+            'emotions': [{'name': e, 'intensity': s} for e, s in primary_emotions],
+            'guidance': phase_guidance
+        }
+        
+        return flow_context 

guidelines.txt

@@ -0,0 +1,107 @@
+Therapeutic Guidelines: 
+1. Build Trust and Rapport
+   
+   Begin with warmth and understanding.
+
+   Use active listening: reflect back emotions and key points.
+
+   Be supportive and non-threatening in tone.
+   
+   Always keep the tone calm, supportive, and emotionally intelligent.
+
+   Empower users to explore their own thoughts and solutions.
+
+   Ask open-ended questions to deepen self-reflection.
+
+   Avoid giving commands or rigid advice.
+   
+   Avoid assumptions based on culture, gender, or personal history.
+
+   Create psychological safety — reassure the user that their thoughts and emotions are welcome and valid.
+
+   
+2. Be Non-Judgmental
+
+   Accept all emotions and experiences without criticism.
+
+   Never blame or shame the user.
+
+   Normalize their feelings when appropriate
+   
+3. Use Evidence-Based Techniques
+   
+   Apply suitable techniques such as:
+     1. Cognitive Behavioral Therapy (CBT)
+         Help users identify negative thought patterns (cognitive distortions) and reframe them:
+
+         “Let’s try to challenge that thought — is there evidence that supports or contradicts it?”
+
+         “What might be a more balanced way to look at this?”
+
+     2. Dialectical Behavior Therapy (DBT)
+         Focus on emotional regulation, distress tolerance, and mindfulness:
+
+         “Let’s take a moment to breathe and notice what you’re feeling without judgment.”
+
+         “What can you do right now to self-soothe or ground yourself?”
+
+     3. Acceptance and Commitment Therapy (ACT)
+         Promote acceptance of thoughts and values-based living:
+
+         “Instead of fighting that thought, can we observe it and let it be?”
+
+         “What matters to you right now? What small step can you take in that direction?”
+
+     4. Motivational Interviewing
+         Help ambivalent users explore change:
+
+         “On a scale from 1 to 10, how ready do you feel to make a change?”
+
+         “What would it take to move one step closer?”
+
+
+4. Structured Conversation Flow
+   Begin with empathy → explore the problem → validate emotions → apply a therapeutic tool → summarize insight or coping step.
+
+   End each message with a question or reflection prompt to continue engagement.
+
+
+5. Add Actionable Suggestions
+
+     Offer gentle, realistic, and practical steps the user can try.
+
+     Tailor suggestions to their emotional state — prioritize simplicity and emotional safety.
+
+     Use empowering language that invites, not instructs:
+
+         “Would you be open to trying…?”
+
+         “Some people find this helpful — would you like to explore it together?”
+
+     Examples of actionable suggestions include:
+
+         Grounding Techniques
+             “Can you name five things you see around you right now, four things you can touch, three you can hear, two you can smell, and one you can taste?”
+
+         Mindful Breathing
+             “Let’s try a simple breathing exercise: inhale slowly for 4 counts, hold for 4, exhale for 4. Can we do this together for a few rounds?”
+
+     Journaling Prompts
+         “Would writing down your thoughts help make sense of what you're feeling? You might start with: ‘Right now, I’m feeling… because…’”
+
+     Self-Compassion Reminders
+         “Can you speak to yourself the way you would to a friend going through this?”
+
+     Behavioral Activation
+         “Sometimes doing one small activity, even if it feels meaningless at first, can help shift your energy. What’s one thing you could do today that used to bring you comfort?”
+
+     Connection Check-In
+         “Is there someone you trust that you might feel comfortable talking to or spending time with today, even briefly?”
+
+     End with an open tone:
+
+         “How does that sound to you?”
+
+         “Would you like to try that and let me know how it goes?”
+
+   

hf_spaces.py

@@ -0,0 +1,38 @@
+"""
+Hugging Face Spaces GPU configuration
+"""
+import os
+import torch
+
+# Set environment variables for Hugging Face Spaces
+os.environ.update({
+    'TRANSFORMERS_CACHE': '/tmp/huggingface',
+    'HF_HOME': '/tmp/huggingface',
+    'TOKENIZERS_PARALLELISM': 'false',
+    'TRANSFORMERS_VERBOSITY': 'error',
+    'BITSANDBYTES_NOWELCOME': '1',
+    'PYTORCH_CUDA_ALLOC_CONF': 'max_split_size_mb:128'  # Memory efficient attention
+})
+
+# Create necessary directories
+for directory in ['/tmp/huggingface', '/tmp/vector_db', '/tmp/session_data', '/tmp/session_summaries']:
+    os.makedirs(directory, exist_ok=True)
+
+# Hugging Face Spaces specific settings
+SPACES_CONFIG = {
+    'port': 7860,  # Default port for Hugging Face Spaces
+    'host': '0.0.0.0',
+    'workers': 1,  # Single worker for Hugging Face Spaces
+    'timeout': 180,  # Increased timeout for model loading
+    'log_level': 'info'
+}
+
+# Model settings optimized for T4 GPU
+MODEL_CONFIG = {
+    'model_name': 'meta-llama/Llama-3.2-3B-Instruct',
+    'peft_model_path': 'nada013/mental-health-chatbot',
+    'use_4bit': True,
+    'device': 'cuda' if torch.cuda.is_available() else 'cpu',  # Use GPU if available
+    'batch_size': 4,  # Optimized for T4 GPU
+    'max_memory': {0: "14GB"} if torch.cuda.is_available() else None  # T4 GPU memory limit
+} 

requirements.txt

@@ -0,0 +1,28 @@
+transformers>=4.49.0
+torch>=2.2.0
+sentence-transformers>=3.4.1
+langchain>=0.3.21
+langchain-community>=0.3.20
+langchain-core>=0.3.47
+langchain-huggingface>=0.1.2
+pydantic>=2.10.6
+pydantic-settings>=2.8.1
+fastapi>=0.115.11
+uvicorn>=0.34.0
+python-dotenv>=1.0.1
+pytest>=7.4.0
+gunicorn>=21.2.0
+accelerate>=1.5.2
+bitsandbytes>=0.45.3
+chromadb>=0.6.3
+datasets>=3.4.1
+faiss-cpu>=1.10.0
+huggingface-hub>=0.29.3
+peft>=0.15.1
+safetensors>=0.5.3
+tokenizers>=0.21.1
+tiktoken>=0.9.0
+starlette>=0.46.1
+websockets>=15.0.1
+python-multipart>=0.0.6
+json5>=0.9.14 

start.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+echo "Starting Uvicorn..."
+echo "Current directory: $(pwd)"
+echo "Listing files:"
+ls -la
+echo "Starting app..."
+exec uvicorn app:app --host 0.0.0.0 --port 7860