Initial commit with Git LFS enabled

.dockerignore

@@ -0,0 +1,36 @@
+# Virtual environments
+venv/
+.env
+
+# System files
+.DS_Store
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Git
+.git
+.gitignore
+
+# Local data directories (will be created in container)
+data/
+
+# Test directories
+test_chroma_db/ 

.env.docker

@@ -0,0 +1,6 @@
+# Template for Docker deployment
+# Replace with your actual API keys before deployment or use Hugging Face Spaces Secrets
+OPENAI_API_KEY=your_openai_api_key_here
+LANGCHAIN_API_KEY=your_langchain_api_key_here
+LANGCHAIN_TRACING_V2=true
+LANGCHAIN_PROJECT=MentalHealthCounselorPOC 

.env.example

@@ -0,0 +1,4 @@
+OPENAI_API_KEY=
+LANGCHAIN_API_KEY=
+LANGCHAIN_TRACING_V2='true'
+LANGCHAIN_PROJECT=

.gitattributes

@@ -0,0 +1,42 @@
+*.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
+# Set up Git LFS for large files
+*.sqlite3 filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+mental_health_model_artifacts/chroma_db/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+mental_health_model_artifacts/chroma_db/**/*.bin filter=lfs diff=lfs merge=lfs -text
+mental_health_model_artifacts/**/*.pkl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,56 @@
+# Virtual environments
+venv/
+env/
+ENV/
+.env
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# OS specific
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# IDE specific
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Local data directories (optional - you might want to keep these)
+# Uncomment if you don't want to track these
+# data/
+
+# Test directories
+test_chroma_db/
+
+# Logs
+logs/
+*.log 

Backend/Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.13-slim
+
+WORKDIR /app
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Download NLTK data
+RUN python -c "import nltk; nltk.download('punkt'); nltk.download('wordnet'); nltk.download('stopwords')"
+
+# Create necessary directories
+RUN mkdir -p data/users data/sessions data/conversations data/feedback
+
+# Copy only the necessary files
+COPY api_mental_health.py .
+COPY .env.example .env
+COPY create_vector_db.py .
+COPY mental_health_model_artifacts/ mental_health_model_artifacts/
+
+# Expose the port Hugging Face Spaces expects
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "api_mental_health:app", "--host", "0.0.0.0", "--port", "7860"] 

Dockerfile

@@ -0,0 +1,48 @@
+FROM python:3.13-slim
+
+WORKDIR /app
+
+# Install git and git-lfs for downloading large files (if needed)
+RUN apt-get update && \
+    apt-get install -y git git-lfs && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Download NLTK data
+RUN python -c "import nltk; nltk.download('punkt'); nltk.download('wordnet'); nltk.download('stopwords')"
+
+# Create necessary directories
+RUN mkdir -p data/users data/sessions data/conversations data/feedback
+RUN mkdir -p mental_health_model_artifacts/chroma_db
+
+# Copy application files
+COPY api_mental_health.py .
+COPY .env.example .env
+COPY create_vector_db.py .
+
+# Copy model artifacts if they exist, or they should be mounted/downloaded at runtime
+# Note: For Hugging Face Spaces deployment, you'll need to use Git LFS or 
+# provide a way to download these models at container startup
+COPY mental_health_model_artifacts/ mental_health_model_artifacts/
+
+# Create a startup script to handle potential model downloading
+RUN echo '#!/bin/bash\n\
+# Check if models exist\n\
+if [ ! -f "mental_health_model_artifacts/crisis_classifier.pkl" ]; then\n\
+    echo "Warning: Model artifacts not found. Please mount them or implement a download method."\n\
+fi\n\
+# Start the API server\n\
+exec uvicorn api_mental_health:app --host 0.0.0.0 --port 7860\n\
+' > /app/start.sh && chmod +x /app/start.sh
+
+# Expose the port Hugging Face Spaces expects
+EXPOSE 7860
+
+# Use the startup script
+CMD ["/app/start.sh"]

README.md

@@ -0,0 +1,12 @@
+---
+title: Thera Guide Ai
+emoji: 🚀
+colorFrom: green
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+short_description: crisis-detection
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api_mental_health.py

@@ -0,0 +1,1370 @@
+# api_mental_health.py
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form
+from pydantic import BaseModel
+import pandas as pd
+import numpy as np
+import joblib
+import re
+import nltk
+from nltk.tokenize import word_tokenize
+from nltk.stem import WordNetLemmatizer
+from nltk.corpus import stopwords
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+import chromadb
+from chromadb.config import Settings
+from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain_chroma import Chroma
+from openai import OpenAI
+import os
+from dotenv import load_dotenv
+from langsmith import Client, traceable
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.prompts import ChatPromptTemplate
+import logging
+from typing import List, Dict, Optional, Any, Union, Annotated
+from datetime import datetime
+from uuid import uuid4, UUID
+import json
+import requests
+from fastapi.responses import StreamingResponse
+from io import BytesIO
+import base64
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+# Download required NLTK data
+nltk.download('punkt')
+nltk.download('wordnet')
+nltk.download('stopwords')
+
+# Initialize FastAPI app
+app = FastAPI(title="Mental Health Counselor API")
+
+# Initialize global storage (to be replaced with proper database)
+DATA_DIR = os.path.join(os.path.dirname(__file__), "data")
+os.makedirs(DATA_DIR, exist_ok=True)
+os.makedirs(os.path.join(DATA_DIR, "users"), exist_ok=True)
+os.makedirs(os.path.join(DATA_DIR, "sessions"), exist_ok=True)
+os.makedirs(os.path.join(DATA_DIR, "conversations"), exist_ok=True)
+os.makedirs(os.path.join(DATA_DIR, "feedback"), exist_ok=True)
+
+# Initialize components
+STOPWORDS = set(stopwords.words("english"))
+lemmatizer = WordNetLemmatizer()
+analyzer = SentimentIntensityAnalyzer()
+output_dir = "mental_health_model_artifacts"
+
+# Global variables for models and vector store
+response_clf = None
+crisis_clf = None
+vectorizer = None
+le = None
+selector = None
+lda = None
+vector_store = None
+llm = None
+openai_client = None
+langsmith_client = None
+
+# Load models and initialize ChromaDB at startup
+@app.on_event("startup")
+async def startup_event():
+    global response_clf, crisis_clf, vectorizer, le, selector, lda, vector_store, llm, openai_client, langsmith_client
+    
+    # Check environment variables
+    if not os.environ.get("OPENAI_API_KEY"):
+        logger.error("OPENAI_API_KEY not set in .env file")
+        raise HTTPException(status_code=500, detail="OPENAI_API_KEY not set in .env file")
+    if not os.environ.get("LANGCHAIN_API_KEY"):
+        logger.error("LANGCHAIN_API_KEY not set in .env file")
+        raise HTTPException(status_code=500, detail="LANGCHAIN_API_KEY not set in .env file")
+    os.environ["LANGCHAIN_TRACING_V2"] = "true"
+    os.environ["LANGCHAIN_PROJECT"] = "MentalHealthCounselorPOC"
+
+    # Initialize LangSmith client
+    logger.info("Initializing LangSmith client")
+    langsmith_client = Client()
+
+    # Load saved components
+    logger.info("Loading model artifacts")
+    try:
+        response_clf = joblib.load(f"{output_dir}/response_type_classifier.pkl")
+        crisis_clf = joblib.load(f"{output_dir}/crisis_classifier.pkl")
+        vectorizer = joblib.load(f"{output_dir}/tfidf_vectorizer.pkl")
+        le = joblib.load(f"{output_dir}/label_encoder.pkl")
+        selector = joblib.load(f"{output_dir}/feature_selector.pkl")
+        
+        try:
+            lda = joblib.load(f"{output_dir}/lda_model.pkl")
+        except Exception as lda_error:
+            logger.warning(f"Failed to load LDA model: {lda_error}. Creating placeholder model.")
+            from sklearn.decomposition import LatentDirichletAllocation
+            lda = LatentDirichletAllocation(n_components=10, random_state=42)
+            # Note: Placeholder is untrained; retrain for accurate results
+            
+    except FileNotFoundError as e:
+        logger.error(f"Missing model artifact: {e}")
+        raise HTTPException(status_code=500, detail=f"Missing model artifact: {e}")
+
+    # Initialize ChromaDB
+    chroma_db_path = f"{output_dir}/chroma_db"
+    if not os.path.exists(chroma_db_path):
+        logger.error(f"ChromaDB not found at {chroma_db_path}. Run create_vector_db.py first.")
+        raise HTTPException(status_code=500, detail=f"ChromaDB not found at {chroma_db_path}. Run create_vector_db.py first.")
+    
+    try:
+        logger.info("Initializing ChromaDB")
+        chroma_client = chromadb.PersistentClient(
+            path=chroma_db_path,
+            settings=Settings(anonymized_telemetry=False)
+        )
+
+        embeddings = OpenAIEmbeddings(
+            model="text-embedding-ada-002",
+            api_key=os.environ["OPENAI_API_KEY"],
+            disallowed_special=(), 
+            chunk_size=1000  
+        )
+        global vector_store
+        vector_store = Chroma(
+            client=chroma_client,
+            collection_name="mental_health_conversations",
+            embedding_function=embeddings
+        )
+    except Exception as e:
+        logger.error(f"Error initializing ChromaDB: {e}")
+        raise HTTPException(status_code=500, detail=f"Error initializing ChromaDB: {e}")
+
+    # Initialize OpenAI client and LLM
+    logger.info("Initializing OpenAI client and LLM")
+    global openai_client, llm
+    openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
+    llm = ChatOpenAI(
+        model="gpt-4o-mini",
+        temperature=0.7,
+        api_key=os.environ["OPENAI_API_KEY"]
+    )
+
+# Pydantic model for request
+class PatientContext(BaseModel):
+    context: str
+
+# New Pydantic models for expanded API functionality
+class UserProfile(BaseModel):
+    user_id: Optional[str] = None
+    username: str
+    name: str
+    role: str = "counselor"
+    specializations: List[str] = []
+    years_experience: Optional[int] = None
+    custom_crisis_keywords: List[str] = []
+    preferences: Dict[str, Any] = {}
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+class SessionData(BaseModel):
+    session_id: Optional[str] = None
+    counselor_id: str
+    patient_identifier: str  # Anonymized ID
+    session_notes: str = ""
+    session_preferences: Dict[str, Any] = {}
+    crisis_keywords: List[str] = []
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    
+class ConversationEntry(BaseModel):
+    session_id: str
+    message: str
+    sender: str  # 'patient' or 'counselor'
+    timestamp: Optional[datetime] = None
+    suggested_response: Optional[str] = None
+    response_type: Optional[str] = None
+    crisis_flag: bool = False
+    risk_level: Optional[str] = None
+    
+class FeedbackData(BaseModel):
+    suggestion_id: str
+    counselor_id: str
+    rating: int  # 1-5 scale
+    was_effective: bool
+    comments: Optional[str] = None
+    
+class AnalysisRequest(BaseModel):
+    text: str
+    patient_background: Optional[Dict[str, Any]] = None
+    patient_age: Optional[int] = None
+    cultural_context: Optional[str] = None
+    
+class MultiModalInput(BaseModel):
+    session_id: str
+    counselor_id: str
+    input_type: str  # 'text', 'audio', 'video'
+    content: str  # Text content or file path/url
+    metadata: Dict[str, Any] = {}
+    
+class InterventionRequest(BaseModel):
+    patient_issue: str
+    patient_background: Optional[Dict[str, Any]] = None
+    intervention_type: Optional[str] = None  # e.g., 'CBT', 'DBT', 'mindfulness'
+
+# Text preprocessing function
+@traceable(run_type="tool", name="Clean Text")
+def clean_text(text):
+    if pd.isna(text):
+        return ""
+    text = str(text).lower()
+    text = re.sub(r"[^a-zA-Z']", " ", text)
+    tokens = word_tokenize(text)
+    tokens = [lemmatizer.lemmatize(tok) for tok in tokens if tok not in STOPWORDS and len(tok) > 2]
+    return " ".join(tokens)
+
+# Feature engineering function
+@traceable(run_type="tool", name="Engineer Features")
+def engineer_features(context, response=""):
+    context_clean = clean_text(context)
+    context_len = len(context_clean.split())
+    context_vader = analyzer.polarity_scores(context)['compound']
+    context_questions = context.count('?')
+    crisis_keywords = ['suicide', 'hopeless', 'worthless', 'kill', 'harm', 'desperate', 'overwhelmed', 'alone']
+    context_crisis_score = sum(1 for word in crisis_keywords if word in context.lower())
+    
+    context_tfidf = vectorizer.transform([context_clean]).toarray()
+    tfidf_cols = [f"tfidf_context_{i}" for i in range(context_tfidf.shape[1])]
+    response_tfidf = np.zeros_like(context_tfidf)
+    
+    lda_topics = lda.transform(context_tfidf)
+    
+    feature_cols = ["context_len", "context_vader", "context_questions", "crisis_flag"] + \
+                   [f"topic_{i}" for i in range(10)] + tfidf_cols + \
+                   [f"tfidf_response_{i}" for i in range(response_tfidf.shape[1])]
+    
+    features = pd.DataFrame({
+        "context_len": [context_len],
+        "context_vader": [context_vader],
+        "context_questions": [context_questions],
+        **{f"topic_{i}": [lda_topics[0][i]] for i in range(10)},
+        **{f"tfidf_context_{i}": [context_tfidf[0][i]] for i in range(context_tfidf.shape[1])},
+        **{f"tfidf_response_{i}": [response_tfidf[0][i]] for i in range(response_tfidf.shape[1])},
+    })
+    
+    crisis_features = features[["context_len", "context_vader", "context_questions"] + [f"topic_{i}" for i in range(10)]]
+    crisis_flag = crisis_clf.predict(crisis_features)[0]
+    if context_crisis_score > 0:
+        crisis_flag = 1
+    features["crisis_flag"] = crisis_flag
+    
+    return features, feature_cols
+
+# Prediction function
+@traceable(run_type="chain", name="Predict Response Type")
+def predict_response_type(context):
+    features, feature_cols = engineer_features(context)
+    selected_features = selector.transform(features[feature_cols])
+    pred_encoded = response_clf.predict(selected_features)[0]
+    pred_label = le.inverse_transform([pred_encoded])[0]
+    confidence = response_clf.predict_proba(selected_features)[0].max()
+    
+    if "?" in context and context.count("?") > 0:
+        pred_label = "Question"
+    if "trying" in context.lower() and "hard" in context.lower() and not any(kw in context.lower() for kw in ["how", "what", "help"]):
+        pred_label = "Validation"
+    if "trying" in context.lower() and "positive" in context.lower() and not any(kw in context.lower() for kw in ["how", "what", "help"]):
+        pred_label = "Question"
+    
+    crisis_flag = bool(features["crisis_flag"].iloc[0])
+    
+    return {
+        "response_type": pred_label,
+        "crisis_flag": crisis_flag,
+        "confidence": confidence,
+        "features": features.to_dict()
+    }
+
+# RAG suggestion function
+@traceable(run_type="chain", name="RAG Suggestion")
+def generate_suggestion_rag(context, response_type, crisis_flag):
+    results = vector_store.similarity_search_with_score(context, k=3)
+    retrieved_contexts = [
+        f"Patient: {res[0].page_content}\nCounselor: {res[0].metadata['response']} (Type: {res[0].metadata['response_type']}, Crisis: {res[0].metadata['crisis_flag']}, Score: {res[1]:.2f})"
+        for res in results
+    ]
+    
+    prompt_template = ChatPromptTemplate.from_template(
+        """
+        You are an expert mental health counseling assistant. A counselor has provided the following patient situation:
+        
+        Patient Situation: {context}
+        
+        Predicted Response Type: {response_type}
+        Crisis Flag: {crisis_flag}
+        
+        Based on the predicted response type and crisis flag, provide a suggested response for the counselor to use with the patient. The response should align with the response type ({response_type}) and be sensitive to the crisis level.
+        
+        For reference, here are similar cases from past conversations:
+        {retrieved_contexts}
+        
+        Guidelines:
+        - If Crisis Flag is True, prioritize safety, empathy, and suggest immediate resources (e.g., National Suicide Prevention Lifeline at 988).
+        - For 'Empathetic Listening', focus on validating feelings without giving direct advice or questions.
+        - For 'Advice', provide practical, actionable suggestions.
+        - For 'Question', pose an open-ended question to encourage further discussion.
+        - For 'Validation', affirm the patient's efforts or feelings.
+        
+        Output in the following format:
+        ```json
+        {{
+            "suggested_response": "Your suggested response here",
+            "risk_level": "Low/Moderate/High"
+        }}
+        ```
+        """
+    )
+    
+    rag_chain = (
+        {
+            "context": RunnablePassthrough(),
+            "response_type": lambda x: response_type,
+            "crisis_flag": lambda x: "Crisis" if crisis_flag else "No Crisis",
+            "retrieved_contexts": lambda x: "\n".join(retrieved_contexts)
+        }
+        | prompt_template
+        | llm
+    )
+    
+    try:
+        response = rag_chain.invoke(context)
+        return eval(response.content.strip("```json\n").strip("\n```"))
+    except Exception as e:
+        logger.error(f"Error generating RAG suggestion: {e}")
+        raise HTTPException(status_code=500, detail=f"Error generating RAG suggestion: {str(e)}")
+
+# Direct suggestion function
+@traceable(run_type="chain", name="Direct Suggestion")
+def generate_suggestion_direct(context, response_type, crisis_flag):
+    prompt_template = ChatPromptTemplate.from_template(
+        """
+        You are an expert mental health counseling assistant. A counselor has provided the following patient situation:
+        
+        Patient Situation: {context}
+        
+        Predicted Response Type: {response_type}
+        Crisis Flag: {crisis_flag}
+        
+        Provide a suggested response for the counselor to use with the patient, aligned with the response type ({response_type}) and sensitive to the crisis level.
+        
+        Guidelines:
+        - If Crisis Flag is True, prioritize safety, empathy, and suggest immediate resources (e.g., National Suicide Prevention Lifeline at 988).
+        - For 'Empathetic Listening', focus on validating feelings without giving direct advice or questions.
+        - For 'Advice', provide practical, actionable suggestions.
+        - For 'Question', pose an open-ended question to encourage further discussion.
+        - For 'Validation', affirm the patient's efforts or feelings.
+        - Strictly adhere to the response type. For 'Empathetic Listening', do not include questions or advice.
+        
+        Output in the following format:
+        ```json
+        {{
+            "suggested_response": "Your suggested response here",
+            "risk_level": "Low/Moderate/High"
+        }}
+        ```
+        """
+    )
+    
+    direct_chain = (
+        {
+            "context": RunnablePassthrough(),
+            "response_type": lambda x: response_type,
+            "crisis_flag": lambda x: "Crisis" if crisis_flag else "No Crisis"
+        }
+        | prompt_template
+        | llm
+    )
+    
+    try:
+        response = direct_chain.invoke(context)
+        return eval(response.content.strip("```json\n").strip("\n```"))
+    except Exception as e:
+        logger.error(f"Error generating direct suggestion: {e}")
+        raise HTTPException(status_code=500, detail=f"Error generating direct suggestion: {str(e)}")
+
+# User Profile Endpoints
+@app.post("/users/create", response_model=UserProfile)
+async def create_user(profile: UserProfile):
+    """Create a new counselor profile with preferences and specializations."""
+    try:
+        saved_profile = save_user_profile(profile)
+        logger.info(f"Created user profile: {saved_profile.user_id}")
+        return saved_profile
+    except Exception as e:
+        logger.error(f"Error creating user profile: {e}")
+        raise HTTPException(status_code=500, detail=f"Error creating user profile: {str(e)}")
+
+@app.get("/users/{user_id}", response_model=UserProfile)
+async def get_user(user_id: str):
+    """Get a counselor profile by user ID."""
+    profile = get_user_profile(user_id)
+    if not profile:
+        raise HTTPException(status_code=404, detail=f"User profile not found: {user_id}")
+    return profile
+
+@app.put("/users/{user_id}", response_model=UserProfile)
+async def update_user(user_id: str, profile_update: UserProfile):
+    """Update a counselor profile."""
+    existing_profile = get_user_profile(user_id)
+    if not existing_profile:
+        raise HTTPException(status_code=404, detail=f"User profile not found: {user_id}")
+    
+    # Preserve the original user_id
+    profile_update.user_id = user_id
+    # Preserve the original created_at timestamp
+    profile_update.created_at = existing_profile.created_at
+    
+    try:
+        updated_profile = save_user_profile(profile_update)
+        logger.info(f"Updated user profile: {user_id}")
+        return updated_profile
+    except Exception as e:
+        logger.error(f"Error updating user profile: {e}")
+        raise HTTPException(status_code=500, detail=f"Error updating user profile: {str(e)}")
+
+# Session Management Endpoints
+@app.post("/sessions/create", response_model=SessionData)
+async def create_session(session_data: SessionData):
+    """Create a new session with patient identifier (anonymized)."""
+    try:
+        # Verify counselor exists
+        counselor = get_user_profile(session_data.counselor_id)
+        if not counselor:
+            raise HTTPException(status_code=404, detail=f"Counselor not found: {session_data.counselor_id}")
+        
+        # If counselor has custom crisis keywords, add them to the session
+        if counselor.custom_crisis_keywords:
+            session_data.crisis_keywords.extend(counselor.custom_crisis_keywords)
+        
+        saved_session = save_session(session_data)
+        logger.info(f"Created session: {saved_session.session_id}")
+        return saved_session
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating session: {e}")
+        raise HTTPException(status_code=500, detail=f"Error creating session: {str(e)}")
+
+@app.get("/sessions/{session_id}", response_model=SessionData)
+async def get_session_by_id(session_id: str):
+    """Get a session by ID."""
+    session = get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
+    return session
+
+@app.get("/sessions/counselor/{counselor_id}", response_model=List[SessionData])
+async def get_counselor_sessions(counselor_id: str):
+    """Get all sessions for a counselor."""
+    sessions = get_user_sessions(counselor_id)
+    return sessions
+
+@app.put("/sessions/{session_id}", response_model=SessionData)
+async def update_session(session_id: str, session_update: SessionData):
+    """Update a session."""
+    existing_session = get_session(session_id)
+    if not existing_session:
+        raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
+    
+    # Preserve the original session_id and created_at
+    session_update.session_id = session_id
+    session_update.created_at = existing_session.created_at
+    
+    try:
+        updated_session = save_session(session_update)
+        logger.info(f"Updated session: {session_id}")
+        return updated_session
+    except Exception as e:
+        logger.error(f"Error updating session: {e}")
+        raise HTTPException(status_code=500, detail=f"Error updating session: {str(e)}")
+
+# Conversation History Endpoints
+@app.post("/conversations/add", response_model=str)
+async def add_conversation_entry(entry: ConversationEntry):
+    """Add a new entry to a conversation."""
+    try:
+        # Verify session exists
+        session = get_session(entry.session_id)
+        if not session:
+            raise HTTPException(status_code=404, detail=f"Session not found: {entry.session_id}")
+        
+        entry_id = save_conversation_entry(entry)
+        logger.info(f"Added conversation entry: {entry_id}")
+        return entry_id
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error adding conversation entry: {e}")
+        raise HTTPException(status_code=500, detail=f"Error adding conversation entry: {str(e)}")
+
+@app.get("/conversations/{session_id}", response_model=List[ConversationEntry])
+async def get_conversation(session_id: str):
+    """Get conversation history for a session."""
+    try:
+        # Verify session exists
+        session = get_session(session_id)
+        if not session:
+            raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
+        
+        entries = get_conversation_history(session_id)
+        return entries
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error retrieving conversation history: {e}")
+        raise HTTPException(status_code=500, detail=f"Error retrieving conversation history: {str(e)}")
+
+# API Endpoints
+@app.post("/suggest")
+async def get_suggestion(context: PatientContext):
+    logger.info(f"Received suggestion request for context: {context.context}")
+    prediction = predict_response_type(context.context)
+    suggestion_rag = generate_suggestion_rag(context.context, prediction["response_type"], prediction["crisis_flag"])
+    suggestion_direct = generate_suggestion_direct(context.context, prediction["response_type"], prediction["crisis_flag"])
+    
+    return {
+        "context": context.context,
+        "response_type": prediction["response_type"],
+        "crisis_flag": prediction["crisis_flag"],
+        "confidence": prediction["confidence"],
+        "rag_suggestion": suggestion_rag["suggested_response"],
+        "rag_risk_level": suggestion_rag["risk_level"],
+        "direct_suggestion": suggestion_direct["suggested_response"],
+        "direct_risk_level": suggestion_direct["risk_level"]
+    }
+
+@app.post("/session/suggest")
+async def get_session_suggestion(request: dict):
+    """Get suggestion within a session context, with enhanced crisis detection based on session keywords."""
+    try:
+        session_id = request.get("session_id")
+        if not session_id:
+            raise HTTPException(status_code=400, detail="session_id is required")
+        
+        context = request.get("context")
+        if not context:
+            raise HTTPException(status_code=400, detail="context is required")
+        
+        # Get session for custom crisis keywords
+        session = get_session(session_id)
+        if not session:
+            raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
+        
+        # Get conversation history for context
+        conversation_history = get_conversation_history(session_id)
+        
+        # Regular prediction
+        prediction = predict_response_type(context)
+        crisis_flag = prediction["crisis_flag"]
+        
+        # Enhanced crisis detection with custom keywords
+        if not crisis_flag and session.crisis_keywords:
+            for keyword in session.crisis_keywords:
+                if keyword.lower() in context.lower():
+                    crisis_flag = True
+                    logger.info(f"Crisis flag triggered by custom keyword: {keyword}")
+                    break
+        
+        # Generate suggestions
+        suggestion_rag = generate_suggestion_rag(context, prediction["response_type"], crisis_flag)
+        suggestion_direct = generate_suggestion_direct(context, prediction["response_type"], crisis_flag)
+        
+        # Create response
+        response = {
+            "context": context,
+            "response_type": prediction["response_type"],
+            "crisis_flag": crisis_flag,
+            "confidence": prediction["confidence"],
+            "rag_suggestion": suggestion_rag["suggested_response"],
+            "rag_risk_level": suggestion_rag["risk_level"],
+            "direct_suggestion": suggestion_direct["suggested_response"],
+            "direct_risk_level": suggestion_direct["risk_level"],
+            "session_id": session_id
+        }
+        
+        # Save the conversation entry
+        entry = ConversationEntry(
+            session_id=session_id,
+            message=context,
+            sender="patient",
+            suggested_response=suggestion_rag["suggested_response"],
+            response_type=prediction["response_type"],
+            crisis_flag=crisis_flag,
+            risk_level=suggestion_rag["risk_level"]
+        )
+        save_conversation_entry(entry)
+        
+        return response
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting session suggestion: {e}")
+        raise HTTPException(status_code=500, detail=f"Error getting session suggestion: {str(e)}")
+
+# Feedback Endpoints
+@app.post("/feedback")
+async def add_feedback(feedback: FeedbackData):
+    """Add feedback about a suggestion's effectiveness."""
+    try:
+        feedback_id = save_feedback(feedback)
+        logger.info(f"Added feedback: {feedback_id}")
+        return {"feedback_id": feedback_id}
+    except Exception as e:
+        logger.error(f"Error adding feedback: {e}")
+        raise HTTPException(status_code=500, detail=f"Error adding feedback: {str(e)}")
+
+# Tone & Cultural Sensitivity Analysis
+@traceable(run_type="chain", name="Cultural Sensitivity Analysis")
+def analyze_cultural_sensitivity(text: str, cultural_context: Optional[str] = None):
+    """Analyze text for cultural appropriateness and sensitivity."""
+    prompt_template = ChatPromptTemplate.from_template(
+        """
+        You are a cultural sensitivity expert. Analyze the following text for cultural appropriateness:
+        
+        Text: {text}
+        
+        Cultural Context: {cultural_context}
+        
+        Provide an analysis of:
+        1. Cultural appropriateness
+        2. Potential bias or insensitivity
+        3. Suggestions for improvement
+        
+        Output in the following format:
+        ```json
+        {{
+            "cultural_appropriateness_score": 0-10,
+            "issues_detected": ["issue1", "issue2"],
+            "suggestions": ["suggestion1", "suggestion2"],
+            "explanation": "Brief explanation of analysis"
+        }}
+        ```
+        """
+    )
+    
+    analysis_chain = (
+        {
+            "text": RunnablePassthrough(),
+            "cultural_context": lambda x: cultural_context if cultural_context else "General"
+        }
+        | prompt_template
+        | llm
+    )
+    
+    try:
+        response = analysis_chain.invoke(text)
+        return eval(response.content.strip("```json\n").strip("\n```"))
+    except Exception as e:
+        logger.error(f"Error analyzing cultural sensitivity: {e}")
+        raise HTTPException(status_code=500, detail=f"Error analyzing cultural sensitivity: {str(e)}")
+
+@traceable(run_type="chain", name="Age Appropriate Analysis")
+def analyze_age_appropriateness(text: str, age: Optional[int] = None):
+    """Analyze text for age-appropriate language."""
+    prompt_template = ChatPromptTemplate.from_template(
+        """
+        You are an expert in age-appropriate communication. Analyze the following text for age appropriateness:
+        
+        Text: {text}
+        
+        Target Age: {age}
+        
+        Provide an analysis of:
+        1. Age appropriateness
+        2. Complexity level
+        3. Suggestions for improvement
+        
+        Output in the following format:
+        ```json
+        {{
+            "age_appropriateness_score": 0-10,
+            "complexity_level": "Simple/Moderate/Complex",
+            "issues_detected": ["issue1", "issue2"],
+            "suggestions": ["suggestion1", "suggestion2"],
+            "explanation": "Brief explanation of analysis"
+        }}
+        ```
+        """
+    )
+    
+    analysis_chain = (
+        {
+            "text": RunnablePassthrough(),
+            "age": lambda x: str(age) if age else "Adult"
+        }
+        | prompt_template
+        | llm
+    )
+    
+    try:
+        response = analysis_chain.invoke(text)
+        return eval(response.content.strip("```json\n").strip("\n```"))
+    except Exception as e:
+        logger.error(f"Error analyzing age appropriateness: {e}")
+        raise HTTPException(status_code=500, detail=f"Error analyzing age appropriateness: {str(e)}")
+
+@app.post("/analyze/sensitivity")
+async def analyze_text_sensitivity(request: AnalysisRequest):
+    """Analyze text for cultural sensitivity and age appropriateness."""
+    try:
+        cultural_analysis = analyze_cultural_sensitivity(request.text, request.cultural_context)
+        age_analysis = analyze_age_appropriateness(request.text, request.patient_age)
+        
+        return {
+            "text": request.text,
+            "cultural_analysis": cultural_analysis,
+            "age_analysis": age_analysis
+        }
+    except Exception as e:
+        logger.error(f"Error analyzing text sensitivity: {e}")
+        raise HTTPException(status_code=500, detail=f"Error analyzing text sensitivity: {str(e)}")
+
+# Guided Intervention Workflows
+@traceable(run_type="chain", name="Generate Intervention")
+def generate_intervention_workflow(issue: str, intervention_type: Optional[str] = None, background: Optional[Dict] = None):
+    """Generate a structured intervention workflow for a specific issue."""
+    prompt_template = ChatPromptTemplate.from_template(
+        """
+        You are an expert mental health counselor. Generate a structured intervention workflow for the following patient issue:
+        
+        Patient Issue: {issue}
+        
+        Intervention Type: {intervention_type}
+        Patient Background: {background}
+        
+        Provide a step-by-step intervention plan based on evidence-based practices. Include:
+        1. Initial assessment questions
+        2. Specific techniques to apply
+        3. Homework or practice exercises
+        4. Follow-up guidance
+        
+        Output in the following format:
+        ```json
+        {{
+            "intervention_type": "CBT/DBT/ACT/Mindfulness/etc.",
+            "assessment_questions": ["question1", "question2", "question3"],
+            "techniques": [
+                {{
+                    "name": "technique name",
+                    "description": "brief description",
+                    "instructions": "step-by-step instructions"
+                }}
+            ],
+            "exercises": [
+                {{
+                    "name": "exercise name",
+                    "description": "brief description",
+                    "instructions": "step-by-step instructions"
+                }}
+            ],
+            "follow_up": ["follow-up step 1", "follow-up step 2"],
+            "resources": ["resource1", "resource2"]
+        }}
+        ```
+        """
+    )
+    
+    intervention_chain = (
+        {
+            "issue": RunnablePassthrough(),
+            "intervention_type": lambda x: intervention_type if intervention_type else "Best fit",
+            "background": lambda x: str(background) if background else "Not provided"
+        }
+        | prompt_template
+        | llm
+    )
+    
+    try:
+        response = intervention_chain.invoke(issue)
+        return eval(response.content.strip("```json\n").strip("\n```"))
+    except Exception as e:
+        logger.error(f"Error generating intervention workflow: {e}")
+        raise HTTPException(status_code=500, detail=f"Error generating intervention workflow: {str(e)}")
+
+@app.post("/interventions/generate")
+async def get_intervention_workflow(request: InterventionRequest):
+    """Get a structured intervention workflow for a specific patient issue."""
+    try:
+        intervention = generate_intervention_workflow(
+            request.patient_issue, 
+            request.intervention_type, 
+            request.patient_background
+        )
+        
+        return {
+            "patient_issue": request.patient_issue,
+            "intervention": intervention
+        }
+    except Exception as e:
+        logger.error(f"Error generating intervention workflow: {e}")
+        raise HTTPException(status_code=500, detail=f"Error generating intervention workflow: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    if all([response_clf, crisis_clf, vectorizer, le, selector, lda, vector_store, llm]):
+        return {"status": "healthy", "message": "All models and vector store loaded successfully"}
+    logger.error("Health check failed: One or more components not loaded")
+    raise HTTPException(status_code=500, detail="One or more components failed to load")
+
+@app.get("/metadata")
+async def get_metadata():
+    try:
+        collection = vector_store._client.get_collection("mental_health_conversations")
+        count = collection.count()
+        return {"collection_name": "mental_health_conversations", "document_count": count}
+    except Exception as e:
+        logger.error(f"Error retrieving metadata: {e}")
+        raise HTTPException(status_code=500, detail=f"Error retrieving metadata: {str(e)}")
+
+# Database utility functions
+def save_user_profile(profile: UserProfile):
+    if not profile.user_id:
+        profile.user_id = str(uuid4())
+    
+    if not profile.created_at:
+        profile.created_at = datetime.now()
+    
+    profile.updated_at = datetime.now()
+    
+    file_path = os.path.join(DATA_DIR, "users", f"{profile.user_id}.json")
+    with open(file_path, "w") as f:
+        # Convert datetime to string for JSON serialization
+        profile_dict = profile.dict()
+        for key in ["created_at", "updated_at"]:
+            if profile_dict[key]:
+                profile_dict[key] = profile_dict[key].isoformat()
+        f.write(json.dumps(profile_dict, indent=2))
+    
+    return profile
+
+def get_user_profile(user_id: str) -> Optional[UserProfile]:
+    file_path = os.path.join(DATA_DIR, "users", f"{user_id}.json")
+    if not os.path.exists(file_path):
+        return None
+    
+    with open(file_path, "r") as f:
+        data = json.loads(f.read())
+        # Convert string dates back to datetime
+        for key in ["created_at", "updated_at"]:
+            if data[key]:
+                data[key] = datetime.fromisoformat(data[key])
+        return UserProfile(**data)
+
+def save_session(session: SessionData):
+    if not session.session_id:
+        session.session_id = str(uuid4())
+    
+    if not session.created_at:
+        session.created_at = datetime.now()
+    
+    session.updated_at = datetime.now()
+    
+    file_path = os.path.join(DATA_DIR, "sessions", f"{session.session_id}.json")
+    with open(file_path, "w") as f:
+        # Convert datetime to string for JSON serialization
+        session_dict = session.dict()
+        for key in ["created_at", "updated_at"]:
+            if session_dict[key]:
+                session_dict[key] = session_dict[key].isoformat()
+        f.write(json.dumps(session_dict, indent=2))
+    
+    return session
+
+def get_session(session_id: str) -> Optional[SessionData]:
+    file_path = os.path.join(DATA_DIR, "sessions", f"{session_id}.json")
+    if not os.path.exists(file_path):
+        return None
+    
+    with open(file_path, "r") as f:
+        data = json.loads(f.read())
+        # Convert string dates back to datetime
+        for key in ["created_at", "updated_at"]:
+            if data[key]:
+                data[key] = datetime.fromisoformat(data[key])
+        return SessionData(**data)
+
+def get_user_sessions(counselor_id: str) -> List[SessionData]:
+    sessions = []
+    sessions_dir = os.path.join(DATA_DIR, "sessions")
+    for filename in os.listdir(sessions_dir):
+        if not filename.endswith(".json"):
+            continue
+        
+        file_path = os.path.join(sessions_dir, filename)
+        with open(file_path, "r") as f:
+            data = json.loads(f.read())
+            if data["counselor_id"] == counselor_id:
+                for key in ["created_at", "updated_at"]:
+                    if data[key]:
+                        data[key] = datetime.fromisoformat(data[key])
+                sessions.append(SessionData(**data))
+    
+    return sessions
+
+def save_conversation_entry(entry: ConversationEntry):
+    conversation_dir = os.path.join(DATA_DIR, "conversations", entry.session_id)
+    os.makedirs(conversation_dir, exist_ok=True)
+    
+    if not entry.timestamp:
+        entry.timestamp = datetime.now()
+    
+    entry_id = str(uuid4())
+    file_path = os.path.join(conversation_dir, f"{entry_id}.json")
+    
+    with open(file_path, "w") as f:
+        # Convert datetime to string for JSON serialization
+        entry_dict = entry.dict()
+        entry_dict["entry_id"] = entry_id
+        if entry_dict["timestamp"]:
+            entry_dict["timestamp"] = entry_dict["timestamp"].isoformat()
+        f.write(json.dumps(entry_dict, indent=2))
+    
+    return entry_id
+
+def get_conversation_history(session_id: str) -> List[ConversationEntry]:
+    conversation_dir = os.path.join(DATA_DIR, "conversations", session_id)
+    if not os.path.exists(conversation_dir):
+        return []
+    
+    entries = []
+    for filename in os.listdir(conversation_dir):
+        if not filename.endswith(".json"):
+            continue
+        
+        file_path = os.path.join(conversation_dir, filename)
+        with open(file_path, "r") as f:
+            data = json.loads(f.read())
+            if data["timestamp"]:
+                data["timestamp"] = datetime.fromisoformat(data["timestamp"])
+            entries.append(ConversationEntry(**data))
+    
+    # Sort by timestamp
+    entries.sort(key=lambda x: x.timestamp)
+    return entries
+
+def save_feedback(feedback: FeedbackData):
+    feedback_id = str(uuid4())
+    file_path = os.path.join(DATA_DIR, "feedback", f"{feedback_id}.json")
+    
+    with open(file_path, "w") as f:
+        feedback_dict = feedback.dict()
+        feedback_dict["feedback_id"] = feedback_id
+        feedback_dict["timestamp"] = datetime.now().isoformat()
+        f.write(json.dumps(feedback_dict, indent=2))
+    
+    return feedback_id
+
+# Multi-modal Input Support
+@app.post("/input/process")
+async def process_multimodal_input(input_data: MultiModalInput):
+    """Process multi-modal input (text, audio, video)."""
+    try:
+        if input_data.input_type not in ["text", "audio", "video"]:
+            raise HTTPException(status_code=400, detail=f"Unsupported input type: {input_data.input_type}")
+        
+        # For now, handle text directly and simulate processing for audio/video
+        if input_data.input_type == "text":
+            # Process text normally
+            prediction = predict_response_type(input_data.content)
+            
+            return {
+                "input_type": "text",
+                "processed_content": input_data.content,
+                "analysis": {
+                    "response_type": prediction["response_type"],
+                    "crisis_flag": prediction["crisis_flag"],
+                    "confidence": prediction["confidence"]
+                }
+            }
+        elif input_data.input_type == "audio":
+            # Simulate audio transcription and emotion detection
+            # In a production system, this would use a speech-to-text API and emotion analysis
+            prompt_template = ChatPromptTemplate.from_template(
+                """
+                Simulate audio processing for this description: {content}
+                
+                Generate a simulated transcription and emotion detection as if this were real audio.
+                
+                Output in the following format:
+                ```json
+                {{
+                    "transcription": "Simulated transcription of the audio",
+                    "emotion_detected": "primary emotion",
+                    "secondary_emotions": ["emotion1", "emotion2"],
+                    "confidence": 0.85
+                }}
+                ```
+                """
+            )
+            
+            process_chain = prompt_template | llm
+            response = process_chain.invoke({"content": input_data.content})
+            audio_result = eval(response.content.strip("```json\n").strip("\n```"))
+            
+            # Now process the transcription
+            prediction = predict_response_type(audio_result["transcription"])
+            
+            return {
+                "input_type": "audio",
+                "processed_content": audio_result["transcription"],
+                "emotion_analysis": {
+                    "primary_emotion": audio_result["emotion_detected"],
+                    "secondary_emotions": audio_result["secondary_emotions"],
+                    "confidence": audio_result["confidence"]
+                },
+                "analysis": {
+                    "response_type": prediction["response_type"],
+                    "crisis_flag": prediction["crisis_flag"],
+                    "confidence": prediction["confidence"]
+                }
+            }
+        elif input_data.input_type == "video":
+            # Simulate video analysis
+            # In a production system, this would use video analytics API
+            prompt_template = ChatPromptTemplate.from_template(
+                """
+                Simulate video processing for this description: {content}
+                
+                Generate a simulated analysis as if this were real video with facial expressions and body language.
+                
+                Output in the following format:
+                ```json
+                {{
+                    "transcription": "Simulated transcription of speech in the video",
+                    "facial_expressions": ["expression1", "expression2"],
+                    "body_language": ["posture observation", "gesture observation"],
+                    "primary_emotion": "primary emotion",
+                    "confidence": 0.80
+                }}
+                ```
+                """
+            )
+            
+            process_chain = prompt_template | llm
+            response = process_chain.invoke({"content": input_data.content})
+            video_result = eval(response.content.strip("```json\n").strip("\n```"))
+            
+            # Process the transcription
+            prediction = predict_response_type(video_result["transcription"])
+            
+            return {
+                "input_type": "video",
+                "processed_content": video_result["transcription"],
+                "nonverbal_analysis": {
+                    "facial_expressions": video_result["facial_expressions"],
+                    "body_language": video_result["body_language"],
+                    "primary_emotion": video_result["primary_emotion"],
+                    "confidence": video_result["confidence"]
+                },
+                "analysis": {
+                    "response_type": prediction["response_type"],
+                    "crisis_flag": prediction["crisis_flag"],
+                    "confidence": prediction["confidence"]
+                }
+            }
+    except Exception as e:
+        logger.error(f"Error processing multimodal input: {e}")
+        raise HTTPException(status_code=500, detail=f"Error processing multimodal input: {str(e)}")
+
+# Therapeutic Technique Suggestions
+@traceable(run_type="chain", name="Therapeutic Techniques")
+def suggest_therapeutic_techniques(context: str, technique_type: Optional[str] = None):
+    """Suggest specific therapeutic techniques based on the patient context."""
+    prompt_template = ChatPromptTemplate.from_template(
+        """
+        You are an expert mental health professional with extensive knowledge of therapeutic techniques. Based on the following patient context, suggest therapeutic techniques that would be appropriate:
+        
+        Patient Context: {context}
+        
+        Technique Type (if specified): {technique_type}
+        
+        Suggest specific therapeutic techniques, exercises, or interventions that would be helpful for this patient. Include:
+        1. Name of technique
+        2. Brief description
+        3. How to apply it in this specific case
+        4. Expected benefits
+        
+        Provide a range of options from different therapeutic approaches (CBT, DBT, ACT, mindfulness, motivational interviewing, etc.) unless a specific technique type was requested.
+        
+        Output in the following format:
+        ```json
+        {{
+            "primary_approach": "The most appropriate therapeutic approach",
+            "techniques": [
+                {{
+                    "name": "Technique name",
+                    "approach": "CBT/DBT/ACT/etc.",
+                    "description": "Brief description",
+                    "application": "How to apply to this specific case",
+                    "benefits": "Expected benefits"
+                }}
+            ],
+            "rationale": "Brief explanation of why these techniques were selected"
+        }}
+        ```
+        """
+    )
+    
+    technique_chain = (
+        {
+            "context": RunnablePassthrough(),
+            "technique_type": lambda x: technique_type if technique_type else "Any appropriate"
+        }
+        | prompt_template
+        | llm
+    )
+    
+    try:
+        response = technique_chain.invoke(context)
+        return eval(response.content.strip("```json\n").strip("\n```"))
+    except Exception as e:
+        logger.error(f"Error suggesting therapeutic techniques: {e}")
+        raise HTTPException(status_code=500, detail=f"Error suggesting therapeutic techniques: {str(e)}")
+
+@app.post("/techniques/suggest")
+async def get_therapeutic_techniques(request: dict):
+    """Get suggested therapeutic techniques for a patient context."""
+    try:
+        context = request.get("context")
+        if not context:
+            raise HTTPException(status_code=400, detail="context is required")
+        
+        technique_type = request.get("technique_type")
+        
+        techniques = suggest_therapeutic_techniques(context, technique_type)
+        
+        return {
+            "context": context,
+            "techniques": techniques
+        }
+    except Exception as e:
+        logger.error(f"Error getting therapeutic techniques: {e}")
+        raise HTTPException(status_code=500, detail=f"Error getting therapeutic techniques: {str(e)}")
+
+# Ethical AI Guardrails - Confidence Indicator
+@app.post("/suggest/with_confidence")
+async def get_suggestion_with_confidence(context: PatientContext):
+    """Get suggestion with detailed confidence indicators and uncertainty flags."""
+    try:
+        # Get standard prediction
+        prediction = predict_response_type(context.context)
+        
+        # Set confidence thresholds
+        high_confidence = 0.8
+        medium_confidence = 0.6
+        
+        # Determine confidence level
+        confidence_value = prediction["confidence"]
+        if confidence_value >= high_confidence:
+            confidence_level = "High"
+        elif confidence_value >= medium_confidence:
+            confidence_level = "Medium"
+        else:
+            confidence_level = "Low"
+        
+        # Analyze for potential biases
+        bias_prompt = ChatPromptTemplate.from_template(
+            """
+            You are an AI ethics expert. Analyze the following patient context and proposed response type for potential biases:
+            
+            Patient Context: {context}
+            Predicted Response Type: {response_type}
+            
+            Identify any potential biases in interpretation or response. Consider gender, cultural, socioeconomic, and other potential biases.
+            
+            Output in the following format:
+            ```json
+            {{
+                "bias_detected": true/false,
+                "bias_types": ["bias type 1", "bias type 2"],
+                "explanation": "Brief explanation of potential biases"
+            }}
+            ```
+            """
+        )
+        
+        bias_chain = (
+            {
+                "context": lambda x: context.context,
+                "response_type": lambda x: prediction["response_type"]
+            }
+            | bias_prompt
+            | llm
+        )
+        
+        bias_analysis = eval(bias_chain.invoke({}).content.strip("```json\n").strip("\n```"))
+        
+        # Generate suggestions
+        suggestion_rag = generate_suggestion_rag(context.context, prediction["response_type"], prediction["crisis_flag"])
+        suggestion_direct = generate_suggestion_direct(context.context, prediction["response_type"], prediction["crisis_flag"])
+        
+        return {
+            "context": context.context,
+            "response_type": prediction["response_type"],
+            "crisis_flag": prediction["crisis_flag"],
+            "confidence": {
+                "value": prediction["confidence"],
+                "level": confidence_level,
+                "uncertainty_flag": confidence_level == "Low"
+            },
+            "bias_analysis": bias_analysis,
+            "rag_suggestion": suggestion_rag["suggested_response"],
+            "rag_risk_level": suggestion_rag["risk_level"],
+            "direct_suggestion": suggestion_direct["suggested_response"],
+            "direct_risk_level": suggestion_direct["risk_level"],
+            "attribution": {
+                "ai_generated": True,
+                "model_version": "Mental Health Counselor API v2.0",
+                "human_reviewed": False
+            }
+        }
+    except Exception as e:
+        logger.error(f"Error getting suggestion with confidence: {e}")
+        raise HTTPException(status_code=500, detail=f"Error getting suggestion with confidence: {str(e)}")
+
+# Text to Speech with Eleven Labs API
+@app.post("/api/text-to-speech")
+async def text_to_speech(request: dict):
+    """Convert text to speech using Eleven Labs API."""
+    try:
+        text = request.get("text")
+        voice_id = request.get("voice_id", "pNInz6obpgDQGcFmaJgB") # Default to "Adam" voice
+        
+        if not text:
+            raise HTTPException(status_code=400, detail="Text is required")
+        
+        # Get API key from environment
+        api_key = os.getenv("ELEVEN_API_KEY")
+        if not api_key:
+            raise HTTPException(status_code=500, detail="Eleven Labs API key not configured")
+        
+        # Prepare the request to Eleven Labs
+        url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
+        
+        headers = {
+            "Accept": "audio/mpeg",
+            "Content-Type": "application/json",
+            "xi-api-key": api_key
+        }
+        
+        payload = {
+            "text": text,
+            "model_id": "eleven_multilingual_v2",
+            "voice_settings": {
+                "stability": 0.5,
+                "similarity_boost": 0.75
+            }
+        }
+        
+        # Make the request to Eleven Labs
+        response = requests.post(url, json=payload, headers=headers)
+        
+        if response.status_code != 200:
+            logger.error(f"Eleven Labs API error: {response.text}")
+            raise HTTPException(status_code=response.status_code, 
+                               detail=f"Eleven Labs API error: {response.text}")
+        
+        # Return audio as streaming response
+        return StreamingResponse(
+            BytesIO(response.content),
+            media_type="audio/mpeg"
+        )
+        
+    except Exception as e:
+        logger.error(f"Error in text-to-speech: {str(e)}")
+        if not isinstance(e, HTTPException):
+            raise HTTPException(status_code=500, detail=f"Text-to-speech error: {str(e)}")
+        raise e
+
+# Multimedia file processing (speech to text)
+@app.post("/api/input/process")
+async def process_audio_input(
+    audio: UploadFile = File(...),
+    session_id: str = Form(...)
+):
+    """Process audio input for speech-to-text using Eleven Labs."""
+    try:
+        # Get API key from environment
+        api_key = os.getenv("ELEVEN_API_KEY")
+        if not api_key:
+            raise HTTPException(status_code=500, detail="Eleven Labs API key not configured")
+        
+        # Read the audio file content
+        audio_content = await audio.read()
+        
+        # Call Eleven Labs Speech-to-Text API
+        url = "https://api.elevenlabs.io/v1/speech-to-text"
+        
+        headers = {
+            "xi-api-key": api_key
+        }
+        
+        # Create form data with the audio file
+        files = {
+            'audio': ('audio.webm', audio_content, 'audio/webm')
+        }
+        
+        data = {
+            'model_id': 'whisper-1'  # Using Whisper model
+        }
+        
+        # Make the request to Eleven Labs
+        response = requests.post(url, headers=headers, files=files, data=data)
+        
+        if response.status_code != 200:
+            logger.error(f"Eleven Labs API error: {response.text}")
+            raise HTTPException(status_code=response.status_code, 
+                              detail=f"Eleven Labs API error: {response.text}")
+        
+        result = response.json()
+        
+        # Extract the transcribed text
+        text = result.get('text', '')
+        
+        # Return the transcribed text
+        return {
+            "text": text,
+            "session_id": session_id
+        }
+        
+    except Exception as e:
+        logger.error(f"Error processing audio: {str(e)}")
+        if not isinstance(e, HTTPException):
+            raise HTTPException(status_code=500, detail=f"Audio processing error: {str(e)}")
+        raise e
+
+# Add a custom encoder for bytes objects to prevent UTF-8 decode errors
+def custom_encoder(obj):
+    if isinstance(obj, bytes):
+        try:
+            return obj.decode('utf-8')
+        except UnicodeDecodeError:
+            return base64.b64encode(obj).decode('ascii')
+    raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+# Override the jsonable_encoder function to handle bytes properly
+from fastapi.encoders import jsonable_encoder as original_jsonable_encoder
+
+def safe_jsonable_encoder(*args, **kwargs):
+    try:
+        return original_jsonable_encoder(*args, **kwargs)
+    except UnicodeDecodeError:
+        # If the standard encoder fails with a decode error, 
+        # ensure all bytes are properly handled
+        if args and isinstance(args[0], bytes):
+            return custom_encoder(args[0])
+        raise
+
+# Monkey patch the jsonable_encoder in FastAPI
+import fastapi.encoders
+fastapi.encoders.jsonable_encoder = safe_jsonable_encoder

create_vector_db.py

@@ -0,0 +1,188 @@
+import pandas as pd
+import chromadb
+from chromadb.config import Settings
+from langchain_openai import OpenAIEmbeddings
+import os
+import getpass
+import shutil
+import re
+import nltk
+from nltk.tokenize import word_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+import kagglehub
+from pathlib import Path
+from langsmith import Client, traceable
+
+# Download required NLTK data
+nltk.download('punkt')
+nltk.download('punkt_tab')
+nltk.download('wordnet')
+nltk.download('stopwords')
+
+# Initialize NLTK and VADER
+STOPWORDS = set(stopwords.words("english"))
+lemmatizer = WordNetLemmatizer()
+analyzer = SentimentIntensityAnalyzer()
+
+# Set OpenAI API key
+if not os.environ.get("OPENAI_API_KEY"):
+    os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter OpenAI API Key: ")
+
+# Set LangSmith environment variables
+if not os.environ.get("LANGCHAIN_API_KEY"):
+    os.environ["LANGCHAIN_API_KEY"] = getpass.getpass("Enter LangSmith API Key: ")
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+os.environ["LANGCHAIN_PROJECT"] = "MentalHealthCounselorPOC"
+
+# Initialize LangSmith client
+langsmith_client = Client()
+
+# Define default paths
+DEFAULT_OUTPUT_DIR = os.environ.get("MH_OUTPUT_DIR", "mental_health_model_artifacts")
+DEFAULT_DATASET_PATH = os.environ.get("MH_DATASET_PATH", None)
+
+# Parse command-line arguments (ignore unknown args for Jupyter/Colab)
+import argparse
+parser = argparse.ArgumentParser(description="Create ChromaDB vector database for Mental Health Counselor POC")
+parser.add_argument('--output-dir', default=DEFAULT_OUTPUT_DIR, help="Directory for model artifacts")
+parser.add_argument('--dataset-path', default=DEFAULT_DATASET_PATH, help="Path to train.csv (if already downloaded)")
+args, unknown = parser.parse_known_args()  # Ignore unknown args like -f
+
+# Set paths
+output_dir = args.output_dir
+chroma_db_path = os.path.join(output_dir, "chroma_db")
+dataset_path = args.dataset_path
+
+# Text preprocessing function
+@traceable(run_type="tool", name="Clean Text")
+def clean_text(text):
+    if pd.isna(text):
+        return ""
+    text = str(text).lower()
+    text = re.sub(r"[^a-zA-Z']", " ", text)
+    tokens = word_tokenize(text)
+    tokens = [lemmatizer.lemmatize(tok) for tok in tokens if tok not in STOPWORDS and len(tok) > 2]
+    return " ".join(tokens)
+
+# Response categorization function
+@traceable(run_type="tool", name="Categorize Response")
+def categorize_response(text):
+    text = str(text).lower()
+    labels = []
+    if re.search(r"\?$", text.strip()):
+        return "Question"
+    if any(phrase in text for phrase in ["i understand", "that sounds", "i hear"]):
+        labels.append("Validation")
+    if any(phrase in text for phrase in ["should", "could", "try", "recommend"]):
+        labels.append("Advice")
+    if not labels:
+        sentiment = analyzer.polarity_scores(text)
+        if sentiment['compound'] > 0.3:
+            labels.append("Empathetic Listening")
+        else:
+            labels.append("Advice")
+    return "|".join(labels)
+
+# Load dataset
+@traceable(run_type="tool", name="Load Dataset")
+def load_dataset():
+    try:
+        if dataset_path and os.path.exists(dataset_path):
+            df = pd.read_csv(dataset_path)
+        else:
+            # Download dataset using kagglehub
+            dataset = kagglehub.dataset_download("thedevastator/nlp-mental-health-conversations", path="train.csv")
+            df = pd.read_csv(dataset)
+        print("First 5 records:\n", df.head())
+        return df
+    except Exception as e:
+        print(f"Error loading dataset: {e}")
+        exit(1)
+
+# Main vector database creation
+@traceable(run_type="chain", name="Create Vector Database")
+def create_vector_db():
+    df = load_dataset()
+
+    # Validate and clean dataset
+    if not all(col in df.columns for col in ['Context', 'Response']):
+        print("Error: Dataset missing required columns ('Context', 'Response')")
+        exit(1)
+
+    df = df.dropna(subset=['Context', 'Response']).drop_duplicates()
+    print(f"Cleaned Dataset Shape: {df.shape}")
+
+    # Compute response type and crisis flag
+    crisis_keywords = ['suicide', 'hopeless', 'worthless', 'kill', 'harm', 'desperate', 'overwhelmed', 'alone']
+    df["response_type"] = df["Response"].apply(categorize_response)
+    df["response_type_single"] = df["response_type"].apply(lambda x: x.split("|")[0])
+    df["crisis_flag"] = df["Context"].apply(
+        lambda x: sum(1 for word in crisis_keywords if word in str(x).lower()) > 0
+    )
+
+    # Initialize ChromaDB client
+    try:
+        if os.path.exists(chroma_db_path):
+            print(f"Clearing existing ChromaDB at {chroma_db_path}")
+            shutil.rmtree(chroma_db_path)
+        os.makedirs(chroma_db_path, exist_ok=True)
+        chroma_client = chromadb.PersistentClient(
+            path=chroma_db_path,
+            settings=Settings(anonymized_telemetry=False)
+        )
+    except Exception as e:
+        print(f"Error initializing ChromaDB: {e}")
+        print("Ensure ChromaDB version is compatible (e.g., 0.5.x) and no other processes are accessing the database.")
+        exit(1)
+
+    # Initialize OpenAI embeddings
+    try:
+        embeddings = OpenAIEmbeddings(model="text-embedding-ada-002")
+    except Exception as e:
+        print(f"Error initializing OpenAI embeddings: {e}")
+        exit(1)
+
+    # Create or reset collection
+    collection_name = "mental_health_conversations"
+    try:
+        chroma_client.delete_collection(collection_name)
+        print(f"Deleted existing collection '{collection_name}' if it existed")
+    except:
+        print(f"No existing collection '{collection_name}' to delete")
+    try:
+        collection = chroma_client.create_collection(name=collection_name)
+        print(f"Created new collection '{collection_name}'")
+    except Exception as e:
+        print(f"Error creating Chroma collection: {e}")
+        exit(1)
+
+    # Prepare documents
+    documents = df["Context"].tolist()
+    metadatas = [
+        {
+            "response": row["Response"],
+            "response_type": row["response_type_single"],
+            "crisis_flag": bool(row["crisis_flag"])
+        }
+        for _, row in df.iterrows()
+    ]
+    ids = [f"doc_{i}" for i in range(len(documents))]
+
+    # Generate embeddings and add to collection
+    try:
+        embeddings_vectors = embeddings.embed_documents(documents)
+        collection.add(
+            documents=documents,
+            embeddings=embeddings_vectors,
+            metadatas=metadatas,
+            ids=ids
+        )
+        print(f"Vector database created in {chroma_db_path} with {len(documents)} documents")
+    except Exception as e:
+        print(f"Error generating embeddings or adding to collection: {e}")
+        exit(1)
+
+if __name__ == "__main__":
+    create_vector_db()

data/conversations/2ae6de8a-bf2d-4d01-8269-e13d5cf3d927/9b2ff07a-def6-43a7-9efd-e8ed6e8cdfd6.json

@@ -0,0 +1,11 @@
+{
+  "session_id": "2ae6de8a-bf2d-4d01-8269-e13d5cf3d927",
+  "message": "he said he sick and crazy ",
+  "sender": "patient",
+  "timestamp": "2025-04-29T23:29:05.936691",
+  "suggested_response": "It sounds like you're feeling really overwhelmed right now, and it's completely understandable to feel that way. When someone says they feel sick and crazy, it can be really distressing. I'm here to listen to how you're feeling and to support you through this. Can you tell me more about what you mean by feeling sick and crazy?",
+  "response_type": "Empathetic Listening",
+  "crisis_flag": false,
+  "risk_level": "Low",
+  "entry_id": "9b2ff07a-def6-43a7-9efd-e8ed6e8cdfd6"
+}

data/conversations/33f954fb-f60d-4ea0-bd59-1396253c8cdc/71bea3ca-82ef-4857-93cf-84955c3eddb3.json

@@ -0,0 +1,11 @@
+{
+  "session_id": "33f954fb-f60d-4ea0-bd59-1396253c8cdc",
+  "message": "hello",
+  "sender": "patient",
+  "timestamp": "2025-04-29T23:49:20.830853",
+  "suggested_response": "It sounds like you might be feeling a bit lost or overwhelmed right now. I'm here to listen and support you as you navigate through these feelings. It\u2019s okay to share whatever is on your mind, and I\u2019m here to help you process those emotions.",
+  "response_type": "Empathetic Listening",
+  "crisis_flag": false,
+  "risk_level": "Low",
+  "entry_id": "71bea3ca-82ef-4857-93cf-84955c3eddb3"
+}

data/conversations/5fc04208-6f76-4774-9c40-bda7e0a28caf/2c256fde-2660-453e-b404-37bcc8a8f93a.json

@@ -0,0 +1,11 @@
+{
+  "session_id": "5fc04208-6f76-4774-9c40-bda7e0a28caf",
+  "message": "jjj\n",
+  "sender": "patient",
+  "timestamp": "2025-04-29T23:32:53.999866",
+  "suggested_response": "It sounds like you're feeling overwhelmed and perhaps caught in a cycle of negative thoughts and anxiety. One approach you might consider is practicing mindfulness techniques, such as deep breathing or meditation, which can help center your thoughts and reduce anxiety. Additionally, try setting small, manageable goals for your day to help regain a sense of control. Journaling your thoughts can also be beneficial; it allows you to express and process what you're feeling. If these strategies don't seem to help, consider reaching out to a therapist who can provide you with tailored support.",
+  "response_type": "Advice",
+  "crisis_flag": false,
+  "risk_level": "Low",
+  "entry_id": "2c256fde-2660-453e-b404-37bcc8a8f93a"
+}

data/conversations/5fc04208-6f76-4774-9c40-bda7e0a28caf/72ebbd21-33dc-4148-8905-1d944451c3ba.json

@@ -0,0 +1,11 @@
+{
+  "session_id": "5fc04208-6f76-4774-9c40-bda7e0a28caf",
+  "message": "nn",
+  "sender": "patient",
+  "timestamp": "2025-04-29T23:33:14.386950",
+  "suggested_response": "It sounds like you're feeling overwhelmed and stuck right now. One approach that might help is to break down your situation into smaller, manageable steps. For instance, consider setting specific, realistic goals for yourself each week, whether it's applying for a certain number of jobs, reaching out to a housing organization for support, or even engaging in self-care activities that bring you some joy. Also, communicating openly with your partner about your feelings and struggles could strengthen your connection and provide the support you need during this challenging time. Remember, it's okay to seek help from professionals or support groups that can offer guidance and resources tailored to your situation.",
+  "response_type": "Advice",
+  "crisis_flag": false,
+  "risk_level": "Low",
+  "entry_id": "72ebbd21-33dc-4148-8905-1d944451c3ba"
+}

data/conversations/67e763f8-5a97-491d-977b-2071af8a8abe/ef88b6ba-c13b-49ff-9dfd-33c6e58d1487.json

@@ -0,0 +1,11 @@
+{
+  "session_id": "67e763f8-5a97-491d-977b-2071af8a8abe",
+  "message": "I've been feeling anxious about work lately and having trouble sleeping.",
+  "sender": "patient",
+  "timestamp": "2025-04-30T00:00:09.873980",
+  "suggested_response": "It sounds like work has been weighing heavily on you lately, and it's understandable to feel anxious about it. Sleep difficulties can really add to that stress, making it even harder to cope with daily challenges. You're not alone in feeling this way, and it\u2019s okay to acknowledge how tough this is for you right now. I'm here to listen and support you as you navigate these feelings.",
+  "response_type": "Empathetic Listening",
+  "crisis_flag": false,
+  "risk_level": "Low",
+  "entry_id": "ef88b6ba-c13b-49ff-9dfd-33c6e58d1487"
+}

data/conversations/72f347f1-ba29-4050-bb6c-02e0851e088a/75c4bb13-daa6-415b-8913-6cc584324940.json

@@ -0,0 +1,11 @@
+{
+  "session_id": "72f347f1-ba29-4050-bb6c-02e0851e088a",
+  "message": "ss",
+  "sender": "patient",
+  "timestamp": "2025-04-29T23:46:13.232213",
+  "suggested_response": "It sounds like you\u2019re feeling stuck with your current situation. One approach you might consider is to take some time to reflect on what specifically hasn\u2019t worked for you in the past and why that might be. Identifying any patterns can help you figure out new strategies to try. Additionally, it might be beneficial to set some realistic, small goals for yourself that can lead to gradual progress. Have you thought about discussing your feelings and frustrations with someone you trust or a professional? They can provide additional support and perspective.",
+  "response_type": "Advice",
+  "crisis_flag": false,
+  "risk_level": "Low",
+  "entry_id": "75c4bb13-daa6-415b-8913-6cc584324940"
+}

data/conversations/b132a94e-553b-47cd-a855-fcf853dc8320/6465a103-6163-40e7-b7a5-acb2e475181c.json

@@ -0,0 +1,11 @@
+{
+  "session_id": "b132a94e-553b-47cd-a855-fcf853dc8320",
+  "message": "I feel so anxious all the time, especially at work. My heart races and I can barely breathe.",
+  "sender": "patient",
+  "timestamp": "2025-04-29T23:09:09.291362",
+  "suggested_response": "It sounds like you're experiencing a lot of intense anxiety at work, and that must be incredibly overwhelming. Your feelings of racing heart and difficulty breathing are really important to acknowledge. It's completely understandable to feel this way, especially in a work environment. You're not alone in this experience, and many people struggle with anxiety in similar situations. I'm here to listen and support you as you navigate through these feelings.",
+  "response_type": "Empathetic Listening",
+  "crisis_flag": false,
+  "risk_level": "Low",
+  "entry_id": "6465a103-6163-40e7-b7a5-acb2e475181c"
+}

data/conversations/d5072833-ef63-4ed2-92ab-d1476f81e17d/34e2ac93-7fef-467f-a672-6a5e0638440f.json

@@ -0,0 +1,11 @@
+{
+  "session_id": "d5072833-ef63-4ed2-92ab-d1476f81e17d",
+  "message": "ss",
+  "sender": "patient",
+  "timestamp": "2025-04-30T00:39:25.082732",
+  "suggested_response": "I\u2019m really sorry to hear that you\u2019re feeling this way. It\u2019s important to talk about what you\u2019re experiencing. I strongly encourage you to reach out to someone who can help you right now, like a trusted friend or a mental health professional. If you\u2019re feeling overwhelmed, please consider contacting the National Suicide Prevention Lifeline at 988, where someone is available to listen and support you 24/7. You don\u2019t have to go through this alone, and there are people who want to help you through this tough time.",
+  "response_type": "Advice",
+  "crisis_flag": true,
+  "risk_level": "High",
+  "entry_id": "34e2ac93-7fef-467f-a672-6a5e0638440f"
+}

data/sessions/08f51081-9d82-4a8c-a3f4-c159a584c3a4.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "08f51081-9d82-4a8c-a3f4-c159a584c3a4",
+  "counselor_id": "4ba9d533-2d2a-4f1b-b00e-bd4f58f38fa1",
+  "patient_identifier": "jkl;",
+  "session_notes": "jj",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "kill"
+  ],
+  "created_at": "2025-04-29T23:33:44.792776",
+  "updated_at": "2025-04-29T23:33:44.792785"
+}

data/sessions/139f262d-769d-4c3f-8d04-0cefc2cdd33e.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "139f262d-769d-4c3f-8d04-0cefc2cdd33e",
+  "counselor_id": "4ba9d533-2d2a-4f1b-b00e-bd4f58f38fa1",
+  "patient_identifier": "aaa",
+  "session_notes": "aaa",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "kill"
+  ],
+  "created_at": "2025-04-29T23:31:21.528490",
+  "updated_at": "2025-04-29T23:31:21.528502"
+}

data/sessions/261e6110-82a3-4f26-bc1e-bbebabea059d.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "261e6110-82a3-4f26-bc1e-bbebabea059d",
+  "counselor_id": "4d352ce8-fd66-4756-9ee1-617406668f93",
+  "patient_identifier": "a",
+  "session_notes": "a",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "aa"
+  ],
+  "created_at": "2025-04-30T00:44:03.891455",
+  "updated_at": "2025-04-30T00:44:03.891479"
+}

data/sessions/2ae6de8a-bf2d-4d01-8269-e13d5cf3d927.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "2ae6de8a-bf2d-4d01-8269-e13d5cf3d927",
+  "counselor_id": "ddb6322a-4f73-435b-8734-ff8d32a23bcd",
+  "patient_identifier": "patioan doctor",
+  "session_notes": "intial",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "harm"
+  ],
+  "created_at": "2025-04-29T23:28:49.602630",
+  "updated_at": "2025-04-29T23:28:49.602641"
+}

data/sessions/33f954fb-f60d-4ea0-bd59-1396253c8cdc.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "33f954fb-f60d-4ea0-bd59-1396253c8cdc",
+  "counselor_id": "1dc2a9f3-0e67-4086-9119-be87d1fcf147",
+  "patient_identifier": "said",
+  "session_notes": "anxirty",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "sss"
+  ],
+  "created_at": "2025-04-29T23:49:00.598796",
+  "updated_at": "2025-04-29T23:49:00.598853"
+}

data/sessions/37f38f66-78af-4544-88b9-3c31734c429d.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "37f38f66-78af-4544-88b9-3c31734c429d",
+  "counselor_id": "d31a3577-b6b8-4e2a-a292-5a1a3c373dc5",
+  "patient_identifier": "dd",
+  "session_notes": "dd",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "aa"
+  ],
+  "created_at": "2025-04-29T23:44:41.289712",
+  "updated_at": "2025-04-29T23:44:41.289725"
+}

data/sessions/5fc04208-6f76-4774-9c40-bda7e0a28caf.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "5fc04208-6f76-4774-9c40-bda7e0a28caf",
+  "counselor_id": "4ba9d533-2d2a-4f1b-b00e-bd4f58f38fa1",
+  "patient_identifier": "j",
+  "session_notes": "j",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "kill"
+  ],
+  "created_at": "2025-04-29T23:32:42.976743",
+  "updated_at": "2025-04-29T23:32:42.976795"
+}

data/sessions/67e763f8-5a97-491d-977b-2071af8a8abe.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "67e763f8-5a97-491d-977b-2071af8a8abe",
+  "counselor_id": "3989efcc-7bd0-49a6-8f26-53b0f9169fd5",
+  "patient_identifier": "k",
+  "session_notes": "k",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "aa"
+  ],
+  "created_at": "2025-04-29T23:58:20.679295",
+  "updated_at": "2025-04-29T23:58:20.679338"
+}

data/sessions/72f347f1-ba29-4050-bb6c-02e0851e088a.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "72f347f1-ba29-4050-bb6c-02e0851e088a",
+  "counselor_id": "d31a3577-b6b8-4e2a-a292-5a1a3c373dc5",
+  "patient_identifier": "aa",
+  "session_notes": "aa",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "aa"
+  ],
+  "created_at": "2025-04-29T23:44:35.406566",
+  "updated_at": "2025-04-29T23:44:35.406580"
+}

data/sessions/75289adb-550c-4a4d-9035-ec54f1c954c6.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "75289adb-550c-4a4d-9035-ec54f1c954c6",
+  "counselor_id": "13c3dcfc-d8ff-4305-88fe-8e610bd8457b",
+  "patient_identifier": "s",
+  "session_notes": "ss",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "aa"
+  ],
+  "created_at": "2025-04-30T00:10:28.631177",
+  "updated_at": "2025-04-30T00:10:28.631195"
+}

data/sessions/b0408071-2a67-4cf4-bdf8-593b71dba326.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "b0408071-2a67-4cf4-bdf8-593b71dba326",
+  "counselor_id": "79a850ac-bee6-45e9-8aef-f47fa20dc669",
+  "patient_identifier": "ss",
+  "session_notes": "ss",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "ss"
+  ],
+  "created_at": "2025-04-30T00:39:07.050280",
+  "updated_at": "2025-04-30T00:39:07.050297"
+}

data/sessions/b132a94e-553b-47cd-a855-fcf853dc8320.json

@@ -0,0 +1,13 @@
+{
+  "session_id": "b132a94e-553b-47cd-a855-fcf853dc8320",
+  "counselor_id": "e2d0468b-f229-4b8f-9fa1-95bd9be68eba",
+  "patient_identifier": "anonymous-123",
+  "session_notes": "Initial session with patient experiencing anxiety",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "harm",
+    "end it all"
+  ],
+  "created_at": "2025-04-29T23:08:48.266989",
+  "updated_at": "2025-04-29T23:08:48.266999"
+}

data/sessions/d5072833-ef63-4ed2-92ab-d1476f81e17d.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "d5072833-ef63-4ed2-92ab-d1476f81e17d",
+  "counselor_id": "79a850ac-bee6-45e9-8aef-f47fa20dc669",
+  "patient_identifier": "ss",
+  "session_notes": "ss",
+  "session_preferences": {},
+  "crisis_keywords": [
+    "ss"
+  ],
+  "created_at": "2025-04-30T00:39:16.212728",
+  "updated_at": "2025-04-30T00:39:16.212739"
+}

data/users/13c3dcfc-d8ff-4305-88fe-8e610bd8457b.json

@@ -0,0 +1,16 @@
+{
+  "user_id": "13c3dcfc-d8ff-4305-88fe-8e610bd8457b",
+  "username": "aa",
+  "name": "aa",
+  "role": "counselor",
+  "specializations": [
+    "aa"
+  ],
+  "years_experience": 2,
+  "custom_crisis_keywords": [
+    "aa"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-30T00:10:20.447044",
+  "updated_at": "2025-04-30T00:10:20.447082"
+}

data/users/1dc2a9f3-0e67-4086-9119-be87d1fcf147.json

@@ -0,0 +1,16 @@
+{
+  "user_id": "1dc2a9f3-0e67-4086-9119-be87d1fcf147",
+  "username": "ss",
+  "name": "ss",
+  "role": "counselor",
+  "specializations": [
+    "ss"
+  ],
+  "years_experience": 2,
+  "custom_crisis_keywords": [
+    "sss"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-29T23:48:35.799622",
+  "updated_at": "2025-04-29T23:48:35.799684"
+}

data/users/3989efcc-7bd0-49a6-8f26-53b0f9169fd5.json

@@ -0,0 +1,16 @@
+{
+  "user_id": "3989efcc-7bd0-49a6-8f26-53b0f9169fd5",
+  "username": "aa",
+  "name": "aa",
+  "role": "counselor",
+  "specializations": [
+    "aa"
+  ],
+  "years_experience": 3,
+  "custom_crisis_keywords": [
+    "aa"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-29T23:57:13.574632",
+  "updated_at": "2025-04-29T23:57:13.574662"
+}

data/users/4ba9d533-2d2a-4f1b-b00e-bd4f58f38fa1.json

@@ -0,0 +1,16 @@
+{
+  "user_id": "4ba9d533-2d2a-4f1b-b00e-bd4f58f38fa1",
+  "username": "aa",
+  "name": "aa",
+  "role": "counselor",
+  "specializations": [
+    "aa"
+  ],
+  "years_experience": 2,
+  "custom_crisis_keywords": [
+    "kill"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-29T23:31:15.551397",
+  "updated_at": "2025-04-29T23:31:15.551477"
+}

data/users/4d352ce8-fd66-4756-9ee1-617406668f93.json

@@ -0,0 +1,16 @@
+{
+  "user_id": "4d352ce8-fd66-4756-9ee1-617406668f93",
+  "username": "a",
+  "name": "a",
+  "role": "counselor",
+  "specializations": [
+    "a"
+  ],
+  "years_experience": 3,
+  "custom_crisis_keywords": [
+    "aa"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-30T00:43:58.059383",
+  "updated_at": "2025-04-30T00:43:58.059439"
+}

data/users/70c8bae7-d171-4c2f-a27a-0ba4f3b1778b.json

@@ -0,0 +1,18 @@
+{
+  "user_id": "70c8bae7-d171-4c2f-a27a-0ba4f3b1778b",
+  "username": "counselor1",
+  "name": "Dr. Smith",
+  "role": "counselor",
+  "specializations": [
+    "anxiety",
+    "depression"
+  ],
+  "years_experience": null,
+  "custom_crisis_keywords": [
+    "harm",
+    "end it all"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-29T23:08:25.633537",
+  "updated_at": "2025-04-29T23:08:25.633570"
+}

data/users/79a850ac-bee6-45e9-8aef-f47fa20dc669.json

@@ -0,0 +1,16 @@
+{
+  "user_id": "79a850ac-bee6-45e9-8aef-f47fa20dc669",
+  "username": "ss",
+  "name": "ss",
+  "role": "counselor",
+  "specializations": [
+    "ss"
+  ],
+  "years_experience": 2,
+  "custom_crisis_keywords": [
+    "ss"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-30T00:39:01.718893",
+  "updated_at": "2025-04-30T00:39:01.719090"
+}

data/users/c22207e8-0863-4592-be45-0c68d0ce8df3.json

@@ -0,0 +1,18 @@
+{
+  "user_id": "c22207e8-0863-4592-be45-0c68d0ce8df3",
+  "username": "counselor1",
+  "name": "Dr. Smith",
+  "role": "counselor",
+  "specializations": [
+    "anxiety",
+    "depression"
+  ],
+  "years_experience": null,
+  "custom_crisis_keywords": [
+    "harm",
+    "end it all"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-29T23:21:04.749779",
+  "updated_at": "2025-04-29T23:21:04.749840"
+}

data/users/d31a3577-b6b8-4e2a-a292-5a1a3c373dc5.json

@@ -0,0 +1,16 @@
+{
+  "user_id": "d31a3577-b6b8-4e2a-a292-5a1a3c373dc5",
+  "username": "aa",
+  "name": "aaa",
+  "role": "counselor",
+  "specializations": [
+    "aa"
+  ],
+  "years_experience": 2,
+  "custom_crisis_keywords": [
+    "aa"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-29T23:44:25.851112",
+  "updated_at": "2025-04-29T23:44:25.851163"
+}

data/users/ddb6322a-4f73-435b-8734-ff8d32a23bcd.json

@@ -0,0 +1,16 @@
+{
+  "user_id": "ddb6322a-4f73-435b-8734-ff8d32a23bcd",
+  "username": "Saod",
+  "name": "Dr. Said",
+  "role": "counselor",
+  "specializations": [
+    "trauma"
+  ],
+  "years_experience": 2,
+  "custom_crisis_keywords": [
+    "harm"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-29T23:28:33.424887",
+  "updated_at": "2025-04-29T23:28:33.424918"
+}

data/users/e2d0468b-f229-4b8f-9fa1-95bd9be68eba.json

@@ -0,0 +1,18 @@
+{
+  "user_id": "e2d0468b-f229-4b8f-9fa1-95bd9be68eba",
+  "username": "counselor1",
+  "name": "Dr. Smith",
+  "role": "counselor",
+  "specializations": [
+    "anxiety",
+    "depression"
+  ],
+  "years_experience": null,
+  "custom_crisis_keywords": [
+    "harm",
+    "end it all"
+  ],
+  "preferences": {},
+  "created_at": "2025-04-29T23:08:36.108291",
+  "updated_at": "2025-04-29T23:08:36.108301"
+}

mental_health_model_artifacts/chroma_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0909d32b23bd9ff2d51a06887e46eebe144fe1c465686d7bcbac169d043b4342
+size 40247296

mental_health_model_artifacts/chroma_db/e454ec48-8871-48f0-af58-914c5aace95d/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d2ff57e249a7cba65242d2ca6d9a1ad9eea523eebdeb5bb8435fa5befbc6c05
+size 12568000

mental_health_model_artifacts/chroma_db/e454ec48-8871-48f0-af58-914c5aace95d/header.bin

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

mental_health_model_artifacts/chroma_db/e454ec48-8871-48f0-af58-914c5aace95d/index_metadata.pickle

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

mental_health_model_artifacts/chroma_db/e454ec48-8871-48f0-af58-914c5aace95d/length.bin

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

mental_health_model_artifacts/chroma_db/e454ec48-8871-48f0-af58-914c5aace95d/link_lists.bin

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

mental_health_model_artifacts/crisis_classifier.pkl

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

mental_health_model_artifacts/feature_selector.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74d7063ff7201a6c318e447556bc586db73b21abe2063cc1e2951fe77686eb5d
+size 35715