Initial backend files

Dockerfile

@@ -0,0 +1,45 @@
+# Dockerfile
+
+# --- STAGE 1: Build & Install Dependencies ---
+# Use a Python base image suitable for slim deployments
+FROM python:3.11-slim AS builder
+
+# Set working directory inside the container
+WORKDIR /app
+
+# Install system dependencies needed for some Python packages (like psycopg2 for Postgres)
+# We include curl and build-essential just in case, which is good practice.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libpq-dev \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements file
+COPY requirements.txt .
+
+# Install Python dependencies (transformers, torch, fastapi, pandas, etc.)
+# --no-cache-dir reduces image size
+RUN pip install --no-cache-dir -r requirements.txt
+
+# --- STAGE 2: Final Runtime Image ---
+# Use the same slim base image for the final production environment
+FROM python:3.11-slim AS runtime
+
+# Set working directory
+WORKDIR /app
+
+# Copy only the installed Python packages from the builder stage
+# This saves space by not including build dependencies like build-essential
+COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+
+# Copy application code (main.py, nlp_model.py, database.py)
+COPY ./backend /app/
+
+# IMPORTANT: Set the internal port. Hugging Face Spaces defaults to 7860.
+EXPOSE 7860
+
+# Command to run the application using Uvicorn
+# 0.0.0.0 is needed to listen on all interfaces.
+# --port 7860 must match the EXPOSE and the space.yaml configuration.
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

database.py

@@ -0,0 +1,98 @@
+# database.py (MongoDB Version)
+import pymongo
+from pymongo.errors import ConnectionFailure
+import datetime
+import os
+# from dotenv import load_dotenv
+
+# Optional: Load environment variables from a .env file for security
+# load_dotenv()
+
+# --- Configuration ---
+# Get connection string from environment variable or replace directly
+# Example local URI: "mongodb://localhost:27017/"
+# Example Atlas URI: "mongodb+srv://<username>:<password>@clustername.mongodb.net/..."
+MONGO_URI = os.environ.get("MONGO_URI", "mongodb://localhost:27017/")
+DB_NAME = 'amhci_data_db'
+COLLECTION_NAME = 'checkin_entries'
+# ---------------------
+
+# Global variables for the client and collection objects
+mongo_client = None
+mongo_collection = None
+
+def get_mongo_collection():
+    """
+    Establishes the MongoDB connection and returns the collection object.
+    This function should be called before performing any database operations.
+    """
+    global mongo_client, mongo_collection
+
+    if mongo_collection is not None:
+        return mongo_collection
+
+    try:
+        # Create a connection using MongoClient
+        mongo_client = pymongo.MongoClient(MONGO_URI)
+        
+        # Access the specified database and collection
+        db = mongo_client[DB_NAME]
+        mongo_collection = db[COLLECTION_NAME]
+
+        print(f"Connected to MongoDB: Database '{DB_NAME}', Collection '{COLLECTION_NAME}'")
+        return mongo_collection
+
+    except ConnectionFailure as e:
+        print(f"ERROR: Could not connect to MongoDB: {e}")
+        # Exit the program or handle the error gracefully
+        raise
+
+def close_mongo_connection():
+    """Closes the MongoDB connection."""
+    global mongo_client
+    if mongo_client:
+        mongo_client.close()
+        print("MongoDB connection closed.")
+
+
+def insert_checkin_entry(user_text, sentiment_score, keyword_intensity, anomaly_flag=False):
+    """
+    Inserts a new check-in document into the MongoDB collection.
+    """
+    collection = get_mongo_collection()
+    
+    # MongoDB stores data as documents (Python dictionaries)
+    entry_data = {
+        "timestamp": datetime.datetime.now(), # MongoDB handles datetime objects natively
+        "user_text": user_text,
+        "sentiment_score": sentiment_score,
+        "keyword_intensity": keyword_intensity,
+        "anomaly_flag": anomaly_flag
+    }
+    
+    # Insert the document
+    result = collection.insert_one(entry_data)
+    print(f"Inserted document ID: {result.inserted_id}")
+    return result.inserted_id
+
+# --- Example Usage ---
+if __name__ == '__main__':
+    try:
+        # Example of how to use the insert function
+        insert_checkin_entry(
+            user_text="I feel great today, everything is going well.",
+            sentiment_score=0.9,
+            keyword_intensity=0.1
+        )
+        
+        # Example of reading back data
+        print("\nRetrieving all entries:")
+        for doc in get_mongo_collection().find():
+            print(doc)
+
+    except Exception as e:
+        print(f"An error occurred during database operations: {e}")
+    finally:
+        # Ensure the connection is closed when the script finishes
+        close_mongo_connection()
+

main.py

@@ -0,0 +1,184 @@
+# main.py
+import datetime
+from typing import List, Optional
+
+# Third-party libraries
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import pandas as pd
+
+# Local modules
+from database import get_mongo_collection, insert_checkin_entry, close_mongo_connection
+from nlp_model import analyze_text
+from bson import ObjectId 
+
+# Initialize the FastAPI application
+app = FastAPI()
+
+# --- Pydantic Models for Data Validation ---
+
+class CheckinRequest(BaseModel):
+    """Model for incoming user check-in data."""
+    user_text: str
+
+class CheckinResponse(BaseModel):
+    """Model for data returned after a single check-in."""
+    id: str
+    timestamp: datetime.datetime
+    sentiment_score: float
+    anomaly_flag: bool
+    support_message: Optional[str] = None # The supportive message/nudge
+    user_text: Optional[str] = None
+
+# --- Helper Functions ---
+
+def check_for_anomaly(all_entries: List[dict], new_score: float) -> bool:
+    """
+    Checks if the new score represents a significant, negative shift 
+    using the Interquartile Range (IQR) rule against historical data.
+    """
+    
+    # Needs at least 4 past data points to establish a stable baseline (e.g., 3 days + new day)
+    if len(all_entries) < 4: 
+        return False
+        
+    # Gather only historical scores (sentiment_score is a float from 0.0 to 1.0)
+    historical_scores = [entry['sentiment_score'] for entry in all_entries]
+    
+    df = pd.DataFrame(historical_scores, columns=['score'])
+    
+    # Calculate key statistics (Median and IQR are robust against outliers)
+    Q1 = df['score'].quantile(0.25)
+    Q3 = df['score'].quantile(0.75)
+    IQR = Q3 - Q1
+
+    # Anomaly Rule: 1.5 * IQR below the first quartile (Q1)
+    LOWER_BOUND = Q1 - (1.5 * IQR)
+    
+    # Anomaly is flagged if the new score is significantly below the typical low point.
+    if new_score < LOWER_BOUND:
+        print(f"ANOMALY DETECTED! New Score ({new_score:.2f}) is below Lower Bound ({LOWER_BOUND:.2f})")
+        return True
+        
+    return False
+
+
+def generate_support_message(sentiment_score: float, is_anomaly: bool) -> str:
+    """
+    Generates a supportive message (nudge) based on the analysis.
+    """
+    
+    # 1. Anomaly/Crisis Nudge (Highest Priority)
+    if is_anomaly:
+        return (
+            "⚠️ Significant Change Detected. Your recent entries show a notable dip below your typical baseline. "
+            "Please reach out to a support professional or review your coping strategies. "
+            "Remember: small steps are still progress."
+        )
+
+    # 2. Low Sentiment Nudge
+    if sentiment_score < 0.3: 
+        return (
+            "🫂 It sounds like you are going through a difficult time. "
+            "It's okay to feel overwhelmed. Focus on one small, manageable task today."
+        )
+
+    # 3. Mid-Range/Neutral Nudge
+    elif sentiment_score < 0.6: 
+        return (
+            "⚖️ A steady day is still a good day. If you feel stuck, try a short break or a mindfulness exercise. "
+            "Keep an eye on how you feel tomorrow."
+        )
+
+    # 4. Positive Nudge (Reinforcement)
+    else: 
+        return (
+            "✨ Great job! Your reflection shows a positive mindset. "
+            "Take a moment to recognize what made today successful and carry that momentum forward."
+        )
+
+
+# --- API Endpoints ---
+
+@app.post("/checkin", response_model=CheckinResponse)
+def submit_checkin(request: CheckinRequest):
+    """
+    Receives a new check-in entry, runs AI analysis, checks for anomalies, 
+    saves the data, and returns the result with a supportive message.
+    """
+    
+    try:
+        # 1. Analyze the text using the sentiment model
+        analysis = analyze_text(request.user_text)
+        
+        # 2. Retrieve all past entries for robust anomaly check
+        collection = get_mongo_collection()
+        # Fetch all entries, ordered by time (descending)
+        past_entries = list(collection.find().sort("timestamp", -1))
+        
+        # 3. Check for anomaly
+        is_anomaly = check_for_anomaly(past_entries, analysis["sentiment"])
+        
+        # 4. Generate the supportive message
+        support_message = generate_support_message(analysis["sentiment"], is_anomaly)
+
+        # 5. Save the new entry to the database
+        entry_id = insert_checkin_entry(
+            user_text=request.user_text,
+            sentiment_score=analysis["sentiment"],
+            keyword_intensity=analysis["intensity"],
+            anomaly_flag=is_anomaly
+        )
+        
+        # 6. Return the saved entry ALONGSIDE the generated message
+        return CheckinResponse(
+            id=str(entry_id),
+            timestamp=datetime.datetime.now(),
+            sentiment_score=analysis["sentiment"],
+            anomaly_flag=is_anomaly,
+            support_message=support_message,
+            user_text=request.user_text
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing check-in: {str(e)}")
+        
+# --- 2. GET Endpoint for Timeline Data ---
+@app.get("/timeline", response_model=List[CheckinResponse])
+def get_timeline():
+    try:
+        # Retrieve all entries, ordered by time
+        collection = get_mongo_collection()
+        entries = list(collection.find().sort("timestamp", 1))
+        
+        # Convert MongoDB documents to response format
+        timeline_data = []
+        for entry in entries:
+            timeline_data.append(CheckinResponse(
+                id=str(entry["_id"]),
+                timestamp=entry["timestamp"],
+                sentiment_score=entry["sentiment_score"],
+                anomaly_flag=entry.get("anomaly_flag", False),
+                user_text=entry.get("user_text", "")
+            ))
+        
+        return timeline_data
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error retrieving timeline: {str(e)}")
+
+# --- Health Check Endpoint ---
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "timestamp": datetime.datetime.now()}
+    
+# --- CORS Headers (Crucial for Hosting) ---
+# Enable CORS for frontend development
+from fastapi.middleware.cors import CORSMiddleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173", "http://localhost:3000"], # Vite dev server
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)

nlp_model.py

@@ -0,0 +1,74 @@
+# nlp_model.py
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+
+# --- Configuration ---
+# You can replace this with any specific fine-tuned RoBERTa model ID 
+# from the Hugging Face Model Hub, especially one tuned for mood/stress.
+# Example: 'finiteautomata/bertweet-base-sentiment-analysis' or a more general one.
+MODEL_NAME = "cardiffnlp/twitter-roberta-base-sentiment-latest"
+
+# --- Global Model Initialization ---
+# This runs ONLY ONCE when the FastAPI server starts.
+# We will use a general sentiment pipeline as a placeholder.
+# In a real project, replace this with a fine-tuned mental health model.
+try:
+    print(f"Loading RoBERTa model: {MODEL_NAME}...")
+
+    # Use the pipeline for quick, high-level analysis in a hackathon
+    sentiment_pipeline = pipeline(
+        "sentiment-analysis",
+        model=MODEL_NAME,
+        tokenizer=MODEL_NAME,
+        device=0 if torch.cuda.is_available() else -1 # Use GPU if available
+    )
+
+    # Store the labels (e.g., ['negative', 'neutral', 'positive']) for later use
+    global_labels = sentiment_pipeline.model.config.id2label
+    print(f"Model loaded with labels: {global_labels}")
+
+except Exception as e:
+    print(f"Error loading RoBERTa model: {e}. Check network connection and model name.")
+    sentiment_pipeline = None
+    global_labels = {}
+
+def map_label_to_score(label: str, score: float) -> float:
+    """Maps the model's categorical output (e.g., NEGATIVE) to a numerical 0.0 to 1.0 score."""
+    label = label.upper()
+    
+    # This mapping is arbitrary but necessary for a quantitative timeline chart.
+    if "POSITIVE" in label:
+        return score  # Closer to 1.0 is more positive
+    elif "NEGATIVE" in label:
+        return 1.0 - score  # Closer to 0.0 is more negative
+    else: # NEUTRAL, etc.
+        # Neutral scores should hover near the midpoint (0.5)
+        return 0.5 + (score * 0.1) # Give it a slight boost based on confidence, but keep it centered
+
+def analyze_text(text: str) -> dict:
+    """Performs RoBERTa analysis and returns scores."""
+    if not sentiment_pipeline:
+        return {"sentiment": 0.5, "intensity": 0.0}
+
+    # 1. Run the pipeline on the input text
+    result = sentiment_pipeline(text)[0]
+    
+    label = result['label']
+    raw_score = result['score']
+
+    # 2. Map the result to our desired numerical output
+    numerical_sentiment = map_label_to_score(label, raw_score)
+    
+    # 3. Use the raw confidence score as a proxy for intensity/certainty
+    intensity_score = raw_score 
+
+    # Note: For hackathon extension: You could add a separate NER model 
+    # here to extract keywords like 'hopeless' or 'anxiety' for the intensity score.
+
+    return {
+        "sentiment": numerical_sentiment,  # A continuous score between 0.0 and 1.0
+        "intensity": intensity_score       # The confidence level of the model's prediction
+    }
+
+# Ensure the database.py and main.py files are correctly referencing this updated 
+# 'analyze_text' function and handling the float outputs. (They already do!)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.104.1
+uvicorn>=0.24.0
+pydantic>=2.5.0
+pymongo>=4.6.0
+torch>=2.9.0
+transformers>=4.35.0
+pandas>=2.1.3
+python-dotenv>=1.0.0