int

.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

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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

.gitignore

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

README.md

@@ -0,0 +1,257 @@
+# Mental Health Support Chatbot
+
+A context-aware mental health support chatbot that provides therapeutic responses based on user emotions and maintains conversation history.
+
+## Features
+
+- Emotion detection using state-of-the-art NLP models
+- Context-aware responses
+- Conversation memory
+- Therapeutic techniques integration
+- Risk flag detection and crisis intervention
+  - Automatic detection of high-risk messages
+  - Immediate crisis response protocol
+  - Professional support referral system
+  - Emergency contact information
+- RESTful API interface
+- Session management and summaries
+- User reply tracking for another depression and anxiety detection from text.
+
+
+## Risk Flag Detection
+
+The chatbot automatically monitors messages for potential risk indicators and provides appropriate crisis intervention responses.
+
+### Risk Indicators
+The system detects various risk-related keywords and phrases, including but not limited to:
+- Self-harm references
+- Suicidal ideation
+- Extreme emotional distress
+- Crisis situations
+
+### Crisis Response Protocol
+When risk flags are detected:
+1. Immediate crisis response is triggered
+2. User is provided with:
+   - Emergency contact information
+   - Professional support options
+   - Immediate coping strategies
+3. Option to connect with licensed professionals
+4. Grounding exercises and calming techniques
+
+### Example Crisis Response
+```json
+{
+    "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 ready to support you.I can connect you with one right now if you'd like.Would you like to connect with a professional now,or would you rather keep talking with me for a bit? Either way, I'm here for you.",
+  "session_id": "user123_20240314103000",
+  "risk_detected": true,
+  "crisis_protocol_activated": true
+}
+```
+
+## Setup
+
+1. Install the required dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Download the required NLTK data:
+```bash
+python -m nltk.downloader punkt
+```
+
+3. Run the chatbot server:
+```bash
+python app.py
+```
+
+The server will start on `http://127.0.0.1:8000`
+
+## API Documentation
+
+### Base URL
+```
+http://127.0.0.1:8000
+```
+
+### API Endpoints
+
+#### 1. Start a Session
+```http
+POST /start_session?user_id={user_id}
+```
+
+Example:
+```bash
+curl -X 'POST' \
+  'http://127.0.0.1:8000/start_session?user_id=user123' \
+  -H 'accept: application/json'
+```
+
+Response:
+```json
+{
+    "response": "Hello! I'm here to support you today. How have you been feeling lately?",
+    "session_id": "user123_20240314103000"
+}
+```
+
+#### 2. Send a Message
+```http
+POST /send_message
+Content-Type: application/json
+
+{
+    "user_id": "user123",
+    "message": "I'm feeling anxious today"
+}
+```
+
+Example:
+```bash
+curl -X 'POST' \
+  'http://127.0.0.1:8000/send_message' \
+  -H 'accept: application/json' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "user_id": "user123",
+    "message": "I'\''m feeling anxious today"
+  }'
+```
+
+Response:
+```json
+{
+    "response": "I understand you're feeling anxious. Can you tell me more about what's causing this?",
+    "session_id": "user123_20240314103000"
+}
+```
+
+#### 3. Get User Replies
+```http
+GET /user_replies/{user_id}
+```
+
+Example:
+```bash
+curl -X 'GET' \
+  'http://127.0.0.1:8000/user_replies/user123' \
+  -H 'accept: application/json'
+```
+
+Response:
+```json
+{
+    "user_id": "user123",
+    "timestamp": "2024-03-14T10:30:00",
+    "replies": [
+        {
+            "text": "I'm feeling anxious today",
+            "timestamp": "2024-03-14T10:30:00",
+            "session_id": "user123_20240314103000"
+        }
+    ]
+}
+```
+
+#### 4. Get Session Summary
+```http
+GET /session_summary/{session_id}?include_summary={boolean}&include_recommendations={boolean}&include_emotions={boolean}&include_characteristics={boolean}&include_duration={boolean}&include_phase={boolean}
+```
+
+Example:
+```bash
+curl -X 'GET' \
+  'http://127.0.0.1:8000/session_summary/user123_20240314103000?include_summary=true&include_recommendations=true&include_emotions=true&include_characteristics=false&include_duration=false&include_phase=false' \
+  -H 'accept: application/json'
+```
+
+Response:
+```json
+{
+    "session_id": "user123_20240314103000",
+    "user_id": "user123",
+    "start_time": "2024-03-14T10:30:00",
+    "end_time": "2024-03-14T10:45:00",
+    "summary": "Session focused on anxiety management...",
+    "recommendations": [
+        "Practice deep breathing exercises",
+        "Consider journaling your thoughts"
+    ],
+    "primary_emotions": ["anxiety", "stress"],
+    "emotion_progression": ["anxiety", "calm"],
+    "duration_minutes": 0.0,
+    "current_phase": "unknown",
+    "session_characteristics": {}
+}
+```
+
+#### 5. End Session
+```http
+POST /end_session?user_id={user_id}
+```
+
+Example:
+```bash
+curl -X 'POST' \
+  'http://127.0.0.1:8000/end_session?user_id=user123' \
+  -H 'accept: application/json'
+```
+
+Response: Complete session summary with all fields.
+
+#### 6. Health Check
+```http
+GET /health
+```
+
+Example:
+```bash
+curl -X 'GET' \
+  'http://127.0.0.1:8000/health' \
+  -H 'accept: application/json'
+```
+
+Response:
+```json
+{
+    "status": "healthy"
+}
+```
+
+## Integration Guidelines
+
+### Best Practices
+1. Always store the `session_id` returned from `/start_session`
+2. Use the same `user_id` throughout a conversation
+3. Include appropriate error handling for API responses
+4. Monitor the health endpoint for system status
+
+### Error Handling
+The API returns standard HTTP status codes:
+- 200: Success
+- 400: Bad Request
+- 404: Not Found
+- 500: Internal Server Error
+
+Error responses include a detail message:
+```json
+{
+    "detail": "Error message here"
+}
+```
+
+
+## Important Notes
+
+- This is not a replacement for professional mental health care
+- Always seek professional help for serious mental health concerns
+
+
+## Privacy and Security
+
+- Conversations are stored in memory only
+- No personal data is permanently stored
+- The system is designed to be HIPAA-compliant
+- Users are identified by unique IDs only

app.py

@@ -0,0 +1,197 @@
+from fastapi import FastAPI, 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
+
+# Load environment variables
+load_dotenv()
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Mental Health Chatbot",
+    description="mental health support chatbot",
+    version="1.0.0"
+)
+
+allowed_origins = os.getenv("ALLOWED_ORIGINS", "http://localhost:8000").split(",")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allowed_origins,  
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize chatbot
+chatbot = MentalHealthChatbot(
+    model_name=os.getenv("MODEL_NAME", "meta-llama/Llama-3.2-3B-Instruct"),
+    peft_model_path=os.getenv("PEFT_MODEL_PATH", "llama_fine_tuned"),
+    therapy_guidelines_path=os.getenv("GUIDELINES_PATH", "guidelines.txt"),
+    use_4bit=True
+)
+
+# 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
+
+# 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)"
+        }
+    }
+
+@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))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000) 

chatbot.py

@@ -0,0 +1,828 @@
+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
+
+# 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.FileHandler("mental_health_chatbot.log"), logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+# Suppress warnings
+import warnings
+warnings.filterwarnings('ignore', category=UserWarning)
+
+# Set environment variables
+os.environ.update({
+    'TRANSFORMERS_VERBOSITY': 'error',
+    'TOKENIZERS_PARALLELISM': 'false',
+    'BITSANDBYTES_NOWELCOME': '1'
+})
+
+# 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
+
+        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
+        )
+        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",
+            model_kwargs={"device": self.device}
+        )
+        
+        # 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:
+            return pipeline(
+                "text-classification",
+                model="SamLowe/roberta-base-go_emotions",
+                top_k=None,
+                device_map="auto" if self.device == "cuda" else None
+            )
+        except Exception as e:
+            logger.error(f"Error loading emotion model: {e}")
+            # Fallback 
+            return pipeline(
+                "text-classification", 
+                model="j-hartmann/emotion-english-distilroberta-base", 
+                return_all_scores=True,
+                device_map="auto" if self.device == "cuda" else None
+            )
+    
+    def _initialize_llm(self, model_name: str, use_4bit: bool):
+        try:
+            # Configure quantization if needed
+            if use_4bit:
+                quantization_config = BitsAndBytesConfig(
+                    load_in_4bit=True,
+                    bnb_4bit_compute_dtype=torch.float16,
+                    bnb_4bit_quant_type="nf4",
+                    bnb_4bit_use_double_quant=True,
+                )
+            else:
+                quantization_config = None
+
+            # 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" if self.device == "cuda" else None,
+                trust_remote_code=True
+            )
+
+            # Load tokenizer
+            logger.info("Loading tokenizer")
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            tokenizer.pad_token = tokenizer.eos_token
+
+            # Load PEFT model from Hugging Face
+            logger.info(f"Loading PEFT model from {self.peft_model_path}")
+            model = PeftModel.from_pretrained(base_model, self.peft_model_path)
+            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 self.device == "cuda" 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,468 @@
+import logging
+import json
+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 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] = {}  # 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)
+        
+        # Extract JSON from response
+        import re
+        json_match = re.search(r'\{.*\}', response, re.DOTALL)
+        if json_match:
+            try:
+                evaluation = json.loads(json_match.group(0))
+                
+                # Update goal progress metrics
+                if 'goals_progress' in evaluation:
+                    for goal, score in evaluation['goals_progress'].items():
+                        if goal in current_phase.goals:
+                            current_phase.completion_metrics[goal] = score
+                
+                # Check if we should transition
+                if evaluation.get('should_transition', False):
+                    next_phase_name = evaluation.get('next_phase')
+                    if next_phase_name in self.PHASES:
+                        self._transition_to_phase(user_id, next_phase_name, evaluation.get('reasoning', ''))
+            except json.JSONDecodeError:
+                self._check_time_based_transition(user_id)
+        else:
+            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)
+        
+        # Extract JSON from response
+        import re
+        json_match = re.search(r'\{.*\}', response, re.DOTALL)
+        if json_match:
+            try:
+                characteristics = json.loads(json_match.group(0))
+                # Validate required fields
+                required_fields = [
+                    'alliance_strength', 'engagement_level', 'emotional_pattern',
+                    'cognitive_pattern', 'coping_mechanisms', 'progress_quality',
+                    'recommended_focus'
+                ]
+                if all(field in characteristics for field in required_fields):
+                    session['llm_context']['session_characteristics'] = characteristics
+                    logger.info(f"Updated session characteristics for user {user_id}")
+                else:
+                    logger.warning("Missing required fields in session characteristics")
+            except json.JSONDecodeError:
+                logger.warning("Failed to parse session characteristics from LLM")
+        else:
+            logger.warning("No JSON object found in LLM response")
+    
+    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