init hf

.gitignore

@@ -81,3 +81,14 @@ Thumbs.db
 /summaries/*
 /assets/*
 trace_back_results_30patient_2ad/
+
+# Google Drive credentials (sensitive)
+service-account-key.json
+*service-account*.json
+user_tokens/
+*.pickle
+*.pkl
+
+# Environment variables
+.env
+.env.local

DEPLOY_INSTRUCTIONS.md

@@ -0,0 +1,52 @@
+# 🚀 Steps to Deploy on Hugging Face
+
+## Step 1: Generate a Hugging Face token
+
+1. Visit https://huggingface.co/settings/tokens
+2. Click **“New token”**
+3. Choose **“Write”** permission
+4. Copy the generated token
+
+## Step 2: Log in to Hugging Face
+
+Run in your terminal:
+
+```bash
+huggingface-cli login
+```
+
+Then paste your token when prompted.
+
+Or provide it via environment variable:
+
+```bash
+export HF_TOKEN="your_token"
+huggingface-cli login --token $HF_TOKEN
+```
+
+## Step 3: Deploy the app
+
+Run:
+
+```bash
+gradio deploy
+```
+
+Or use the helper script:
+
+```bash
+./deploy_hf.sh
+```
+
+## Step 4: Add Google Drive secrets (post-deployment)
+
+1. Open your Space page: `https://huggingface.co/spaces/<username>/<space-name>`
+2. Go to the **“Settings”** tab
+3. Under **“Repository secrets”** add:
+   - **Name**: `GOOGLE_SERVICE_ACCOUNT_JSON`
+   - **Value**: paste the full Service Account JSON content
+
+## Done!
+
+Wait 2–5 minutes for the build to finish, then open your Space URL.
+

DEPLOY_NOW.md

@@ -0,0 +1,37 @@
+# 🚀 Deploy to Hugging Face Right Now
+
+## Problem
+The CLI error shows that Space names cannot contain spaces, so you must provide a valid identifier.
+
+## Solution
+
+Run this inside your `chatbot` environment:
+
+```bash
+gradio deploy --space chatbot-mimic-notes
+```
+
+Or include your Hugging Face username:
+
+```bash
+gradio deploy --space your-username/chatbot-mimic-notes
+```
+
+## Valid Space Name Rules
+- ✅ Letters, digits, hyphen `-`, underscore `_`, dot `.`
+- ✅ Cannot start or end with `-` or `.`
+- ✅ `--` and `..` are not allowed
+- ✅ Maximum length 96 characters
+- ❌ No spaces
+
+## Examples
+```bash
+# Valid
+gradio deploy --space chatbot-mimic-notes
+gradio deploy --space my-chatbot-app
+gradio deploy --space chatbot_123
+
+# Invalid (contains spaces)
+gradio deploy --space "Chatbot Mimic Notes"
+```
+

DEPLOY_SIMPLE.md

@@ -0,0 +1,62 @@
+# 🚀 Simplest Deployment Path
+
+Because this version of `gradio deploy` does not accept the `--space` flag, use Git-based deployment instead.
+
+## Option 1: Deployment Script (recommended)
+
+```bash
+./deploy_git.sh
+```
+
+The script automatically:
+1. Checks login status
+2. Creates or updates the Space
+3. Copies files and pushes via Git
+
+## Option 2: Manual Git Workflow
+
+### Step 1: Create the Space
+
+Visit https://huggingface.co/new-space or run:
+
+```bash
+huggingface-cli repo create chatbot-mimic-notes --type space --sdk gradio
+```
+
+### Step 2: Clone the Space
+
+```bash
+git clone https://huggingface.co/spaces/jesseliu/chatbot-mimic-notes
+cd chatbot-mimic-notes
+```
+
+### Step 3: Copy project files
+
+```bash
+# Copy required files
+cp ../chatbot-mimic-notes/chatgpt.py .
+cp ../chatbot-mimic-notes/README.md .
+cp ../chatbot-mimic-notes/requirements.txt .
+cp -r ../chatbot-mimic-notes/src ./src
+cp ../chatbot-mimic-notes/google_drive_sync.py .
+```
+
+### Step 4: Commit and push
+
+```bash
+git add .
+git commit -m "Initial deployment"
+git push
+```
+
+## Done!
+
+Wait 2–5 minutes for the build, then visit:
+https://huggingface.co/spaces/jesseliu/chatbot-mimic-notes
+
+## Configure Google Drive Secrets
+
+1. Open Space Settings
+2. Add secret: `GOOGLE_SERVICE_ACCOUNT_JSON`
+3. Paste the full Service Account JSON content
+

HUGGINGFACE_DEPLOY.md

@@ -0,0 +1,168 @@
+# 🚀 Hugging Face Spaces Deployment Guide
+
+This guide walks through deploying the chatbot to Hugging Face Spaces so you have a permanent HTTPS endpoint.
+
+## 📋 Prerequisites
+
+1. **Hugging Face account**
+   - Sign up at [huggingface.co](https://huggingface.co)
+   - Verify your email
+
+2. **CLI tooling**
+   ```bash
+   pip install huggingface_hub[cli]
+   ```
+
+## 🎯 Deployment Paths
+
+### Option 1: Deployment script (easiest)
+
+```bash
+# 1. Log in to Hugging Face
+huggingface-cli login
+
+# 2. Run the helper script
+python deploy_to_huggingface.py
+```
+
+### Option 2: Gradio CLI
+
+```bash
+huggingface-cli login
+gradio deploy
+```
+
+### Option 3: Manual Git push
+
+```bash
+# 1. Create a Space at https://huggingface.co/new-space (select Gradio SDK)
+
+# 2. Clone the Space repo
+git clone https://huggingface.co/spaces/<username>/<space-name>
+cd <space-name>
+
+# 3. Copy project files
+cp -r /path/to/chatbot-mimic-notes/* .
+
+# 4. Commit and push
+git add .
+git commit -m "Initial deployment"
+git push
+```
+
+## 🔐 Configure Google Drive (important)
+
+Spaces should rely on environment variables for Drive credentials.
+
+### Step 1: Obtain the Service Account JSON
+
+1. Follow `QUICK_SETUP.md`
+2. Download the JSON key file
+
+### Step 2: Add Hugging Face secrets
+
+1. Open `https://huggingface.co/spaces/<username>/<space-name>`
+2. Go to **Settings → Repository secrets**
+3. Add the required secrets:
+
+#### Option A: Service Account (recommended)
+
+1. Copy the full JSON content
+2. Add a secret:
+   - **Name**: `GOOGLE_SERVICE_ACCOUNT_JSON`
+   - **Value**: entire JSON blob
+
+#### Option B: Refresh token flow
+
+Add these secrets if you prefer OAuth refresh tokens:
+- **Name**: `GOOGLE_REFRESH_TOKEN`
+- **Name**: `GOOGLE_CLIENT_ID` (optional override)
+- **Name**: `GOOGLE_CLIENT_SECRET` (optional override)
+
+### Step 3: Environment variable support
+
+The code already reads credentials from environment variables. If you supply the JSON via secret, no extra code changes are needed.
+
+## 📝 README front matter
+
+Ensure the top of `README.md` contains:
+
+```yaml
+---
+title: Chatbot Mimic Notes
+emoji: 🤖
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: 3.50.2
+app_file: chatgpt.py
+pinned: false
+---
+```
+
+## ✅ Post-deployment checklist
+
+1. **Visit the Space**  
+   `https://<username>-<space-name>.hf.space` (build takes ~2–5 minutes)
+
+2. **Smoke test**  
+   - Confirm the UI loads  
+   - Trigger a sample Google Drive sync  
+   - Verify data persistence
+
+3. **Check logs**  
+   - Open the “Logs” tab to inspect errors
+
+## 🔧 Troubleshooting
+
+### Build failed
+
+- Confirm `requirements.txt` lists every dependency
+- Review the build logs
+- Ensure Python 3.10 compatibility
+
+### Google Drive sync fails
+
+1. Verify Space secrets
+2. Confirm the Service Account has Drive access
+3. Ensure the Drive API is enabled
+4. Review runtime logs
+
+### App won’t start
+
+- Make sure `app_file` matches `chatgpt.py`
+- Confirm `chatgpt.py` exists in the repo
+- Read the log output for stack traces
+
+## 📦 Updating the Space
+
+### Via Git
+
+```bash
+cd <space-repo>
+git add .
+git commit -m "Update: describe changes"
+git push
+```
+
+### Via the web UI
+
+1. Open the Space and click **Files**
+2. Upload or edit files
+3. Commit the changes online
+
+## 🎉 What you get
+
+- ✅ Permanent HTTPS URL
+- ✅ Free hosting tier
+- ✅ Automatic certificates
+- ✅ Global CDN
+- ✅ Version history & rollbacks
+
+## 💡 Tips
+
+- **Custom domain**: configure under Space Settings
+- **Resources**: upgrade if you need more CPU/RAM
+- **Private Spaces**: toggle visibility in Settings
+- **Monitoring**: use the built-in analytics/logs
+

QUICK_SETUP.md

@@ -0,0 +1,94 @@
+# 🚀 Google Drive Quick Setup Guide
+
+If you run into `invalid_client` errors, **use the Service Account approach** (simpler and more reliable).
+
+## ⭐ Recommended: Service Account (≈5 minutes)
+
+### Step 1: Create a Service Account (≈2 minutes)
+
+1. Visit [Google Cloud Console](https://console.cloud.google.com/)
+2. Create a new project or select an existing one
+3. Enable the Google Drive API:
+   - Left menu → “APIs & Services” → “Library”
+   - Search “Google Drive API” → click “Enable”
+4. Create the Service Account:
+   - Left menu → “IAM & Admin” → “Service Accounts”
+   - Click “Create Service Account”
+   - Name it `chatbot-drive-uploader`
+   - Click “Create and Continue” → “Done”
+
+### Step 2: Download the key (≈1 minute)
+
+1. Open the Service Account you just created
+2. Go to the “Keys” tab
+3. Click “Add Key” → “Create new key”
+4. Choose **JSON**
+5. Click “Create” (the file downloads automatically)
+6. Rename it to `service-account-key.json`
+7. Place it in the project root (next to `google_drive_sync.py`)
+
+### Step 3: Share the Google Drive folder (≈1 minute)
+
+1. Create a folder in Google Drive (e.g., “Chatbot_Data”)
+2. Right-click → “Share”
+3. Open `service-account-key.json`, find `client_email`
+   - Example: `chatbot-drive-uploader@your-project.iam.gserviceaccount.com`
+4. Invite that email with “Editor” permission
+5. Click “Send”
+
+### Step 4: Update the code (≈1 minute)
+
+Open `google_drive_sync.py` and set:
+
+```python
+SERVICE_ACCOUNT_FILE = "service-account-key.json"
+```
+
+### Done! ✅
+
+All data will now sync to your Drive folder automatically without manual intervention.
+
+---
+
+## 🔄 Alternative: Fix the OAuth client (refresh token flow)
+
+If you prefer refresh tokens, create a new OAuth client.
+
+### Step 1: Create the OAuth client
+
+1. Visit [Google Cloud Console](https://console.cloud.google.com/)
+2. Select your project
+3. Left menu → “APIs & Services” → “Credentials”
+4. Click “Create Credentials” → “OAuth client ID”
+5. If prompted, configure the consent screen (choose “External”)
+6. App name: `Chatbot Drive Uploader`
+7. User support email: your email
+8. Developer contact: your email
+9. Click through “Save and Continue” to finish
+10. Click “Create Credentials” → “OAuth client ID” again
+11. Choose **“Desktop app”**
+12. Name it `Chatbot Desktop Client`
+13. Click “Create”
+14. Copy the **Client ID** and **Client secret**
+
+### Step 2: Update the code
+
+```python
+CLIENT_ID = "your new client id"
+CLIENT_SECRET = "your new client secret"
+```
+
+### Step 3: Fetch a new refresh token
+
+```bash
+python get_refresh_token.py
+```
+
+---
+
+## 📝 Notes
+
+- The Service Account JSON is sensitive — **never commit it to Git**
+- Add `service-account-key.json` to `.gitignore`
+- Service Accounts are safer because no user credentials live in code
+

README.md

@@ -1,10 +1,18 @@
 ---
-title: llm-autobiography
-app_file: chatgpt.py
+title: Chatbot Mimic Notes
+emoji: 🤖
+colorFrom: blue
+colorTo: green
 sdk: gradio
 sdk_version: 3.50.2
+app_file: chatgpt.py
+pinned: false
+license: mit
 ---
-#  Chatbot Frontend
+
+# Chatbot Mimic Notes
+
+A medical-focused chatbot that supports patient evaluations, structured conversation management, and optional Google Drive backups.
 
 ## Prerequisites
 - Python 3.x
@@ -35,3 +43,61 @@ python -m src.server
 
 ## Usage
 - Open Chrome and visit `http://localhost:7860` to interact with the chatbot.
+
+## Google Drive Auto-Backup
+
+The chatbot can automatically push evaluation data to Google Drive so the latest files are available when deploying to Hugging Face.
+
+### Storage Layout
+
+1. **Patient evaluations** (`patient_evaluations/`)
+   - Synced to the `Patient_Evaluations` folder in Drive
+   - Includes per-evaluation JSON files plus the master CSV summary
+
+2. **Conversation logs** (`user_data/`)
+   - Synced to the `Chatbot_Conversations` folder in Drive
+   - Includes conversation transcripts and memory graphs
+
+### Configuration Options (choose one)
+
+#### ⭐ Option 1: Service Account (recommended)
+
+Use this if you see an `invalid_client` error or want a hands-off setup.
+
+1. Create a Service Account in Google Cloud Console and download the JSON key
+2. Share your destination Drive folder with the Service Account email
+3. Update `google_drive_sync.py`:
+   ```python
+   SERVICE_ACCOUNT_FILE = "service-account-key.json"
+   ```
+
+**Full walkthrough (≈5 minutes):** see `QUICK_SETUP.md`
+
+#### Option 2: Refresh Token (requires an OAuth client)
+
+1. Generate a refresh token:
+   ```bash
+   python get_refresh_token.py
+   ```
+2. If you hit `invalid_client`, create a new OAuth client (see `QUICK_SETUP.md`)
+3. Complete the browser authentication flow
+4. Copy the printed `refresh_token`
+5. Update `google_drive_sync.py`:
+   ```python
+   REFRESH_TOKEN = "your_refresh_token"
+   ```
+
+See `google_drive_setup_guide.md` or `QUICK_SETUP.md` for detailed steps.
+
+#### Option 3: Interactive OAuth (manual in UI)
+
+1. Click **“Login to Google Drive”** inside the Gradio interface
+2. Complete the browser authentication
+3. Future saves will automatically sync to Drive
+
+### Notes
+
+- Without authentication, all files remain in local storage
+- Upload failures are silent but local saves always succeed
+- Only your own Drive account receives files; no shared storage is involved
+- **Security:** never commit credentials or tokens into the repo

chatgpt.py

@@ -277,6 +277,18 @@ def save_patient_evaluation(patient_id, patient_input, ai_summary, rating, feedb
             len(sentence_comments) if sentence_comments else 0
         ])
     
+    # Auto-upload to Google Drive if authenticated
+    try:
+        from google_drive_sync import auto_upload_to_drive
+        # Upload JSON file
+        auto_upload_to_drive(eval_file, folder_name="Patient_Evaluations")
+        # Upload CSV file (only if it was just created, to avoid duplicates)
+        if not file_exists:
+            auto_upload_to_drive(csv_file, folder_name="Patient_Evaluations")
+    except Exception as e:
+        # Fail silently if Google Drive upload fails
+        pass
+    
     return f"Patient evaluation saved successfully at {timestamp}"
 
 def submit_patient_evaluation(patient_id, patient_input, ai_summary, overall_rating, 
@@ -1334,11 +1346,22 @@ with gr.Blocks(css=css) as app:
         print("3. Deploy: gradio deploy")
         print("4. This will give you a permanent https://yourname-appname.hf.space URL")
     
-    # For now, launch with share link (72 hour expiry)
-    app.launch(
-        share=True, 
-        max_threads=10,
-        server_name="0.0.0.0",  # Allow external connections
-        server_port=7860,
-        show_error=True
-    )
+    # Check if running on Hugging Face Spaces
+    hf_space = os.getenv("SPACE_ID") is not None
+    
+    if hf_space:
+        # Running on Hugging Face Spaces
+        app.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            show_error=True
+        )
+    else:
+        # Running locally
+        app.launch(
+            share=True, 
+            max_threads=10,
+            server_name="0.0.0.0",  # Allow external connections
+            server_port=7860,
+            show_error=True
+        )

deploy_git.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+
+# Git-based deployment to Hugging Face Spaces
+
+echo "🚀 Chatbot Mimic Notes - Git deployment to Hugging Face"
+echo "======================================================="
+echo ""
+
+# Check login status
+if ! huggingface-cli whoami &> /dev/null; then
+    echo "❌ Not logged into Hugging Face"
+    echo "Run: huggingface-cli login"
+    exit 1
+fi
+
+USERNAME=$(huggingface-cli whoami | head -n 1)
+echo "✅ Logged in as: $USERNAME"
+echo ""
+
+# Prompt for Space name
+read -p "Enter Space name (e.g., chatbot-mimic-notes): " SPACE_NAME
+
+if [ -z "$SPACE_NAME" ]; then
+    echo "❌ Space name cannot be empty"
+    exit 1
+fi
+
+FULL_SPACE_NAME="${USERNAME}/${SPACE_NAME}"
+SPACE_URL="https://huggingface.co/spaces/${FULL_SPACE_NAME}"
+
+echo ""
+echo "📦 Preparing deployment to: $FULL_SPACE_NAME"
+echo ""
+
+# Check if Space exists
+if huggingface-cli repo exists "$FULL_SPACE_NAME" &> /dev/null; then
+    echo "✅ Space already exists: $SPACE_URL"
+    echo "   Updating existing Space"
+else
+    echo "🆕 Creating a new Space..."
+    huggingface-cli repo create "$SPACE_NAME" --type space --sdk gradio
+    if [ $? -ne 0 ]; then
+        echo "❌ Failed to create Space"
+        exit 1
+    fi
+    echo "✅ Space created successfully"
+fi
+
+echo ""
+echo "📤 Preparing Git push..."
+echo ""
+
+# Create temp directory
+TEMP_DIR=$(mktemp -d)
+echo "Temp directory: $TEMP_DIR"
+
+# Clone Space repo
+echo "Cloning Space..."
+git clone "$SPACE_URL.git" "$TEMP_DIR/space" 2>/dev/null || {
+    echo "Clone failed, initializing empty repo..."
+    mkdir -p "$TEMP_DIR/space"
+    cd "$TEMP_DIR/space"
+    git init
+    git remote add origin "$SPACE_URL.git"
+}
+
+cd "$TEMP_DIR/space"
+
+# Copy project files
+echo "Copying files..."
+cp -r /Users/liuzijie/Desktop/chatbot-mimic-notes/chatgpt.py .
+cp -r /Users/liuzijie/Desktop/chatbot-mimic-notes/README.md .
+cp -r /Users/liuzijie/Desktop/chatbot-mimic-notes/requirements.txt .
+cp -r /Users/liuzijie/Desktop/chatbot-mimic-notes/src ./src 2>/dev/null || true
+cp -r /Users/liuzijie/Desktop/chatbot-mimic-notes/google_drive_sync.py . 2>/dev/null || true
+
+# Remove sensitive files
+rm -f service-account-key.json
+rm -rf user_tokens/
+
+# Commit & push
+echo "Committing changes..."
+git add .
+git commit -m "Deploy chatbot application" || echo "No changes to commit"
+git push origin main || git push origin master
+
+echo ""
+echo "✅ Deployment finished!"
+echo "🌐 Space URL: $SPACE_URL"
+echo ""
+echo "💡 Notes:"
+echo "   - First build takes 2–5 minutes"
+echo "   - Configure Google Drive secrets via Space Settings > Repository secrets"
+echo "   - Add secret: GOOGLE_SERVICE_ACCOUNT_JSON"
+
+# Cleanup
+rm -rf "$TEMP_DIR"
+

deploy_hf.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+
+# Quick deployment script for Hugging Face Spaces
+
+echo "🚀 Chatbot Mimic Notes - Hugging Face deployment script"
+echo "======================================================="
+echo ""
+
+# Check login status
+if ! huggingface-cli whoami &> /dev/null; then
+    echo "❌ Not logged into Hugging Face"
+    echo "Run: huggingface-cli login"
+    exit 1
+fi
+
+echo "✅ Logged into Hugging Face"
+USERNAME=$(huggingface-cli whoami | head -n 1)
+echo "   User: $USERNAME"
+echo ""
+
+# Prompt for Space name
+read -p "Enter Space name (e.g., chatbot-mimic-notes): " SPACE_NAME
+
+if [ -z "$SPACE_NAME" ]; then
+    echo "❌ Space name cannot be empty"
+    exit 1
+fi
+
+FULL_SPACE_NAME="${USERNAME}/${SPACE_NAME}"
+
+echo ""
+echo "📦 Preparing deployment to: $FULL_SPACE_NAME"
+echo ""
+
+# Check existing Space
+if huggingface-cli repo exists "$FULL_SPACE_NAME" &> /dev/null; then
+    echo "⚠️  Space already exists; update in place?"
+    read -p "Continue? (y/n): " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        exit 1
+    fi
+else
+    echo "🆕 Creating a new Space..."
+    huggingface-cli repo create "$SPACE_NAME" --type space --sdk gradio
+fi
+
+echo ""
+echo "📤 Starting deployment..."
+echo ""
+
+# Use gradio CLI
+gradio deploy --space "$FULL_SPACE_NAME" --app-file chatgpt.py
+
+echo ""
+echo "✅ Deployment finished!"
+echo "🌐 URL: https://huggingface.co/spaces/$FULL_SPACE_NAME"
+echo ""
+echo "💡 Tips:"
+echo "   - First build takes 2–5 minutes"
+echo "   - Configure Google Drive secrets in Space Settings"
+echo "   - See HUGGINGFACE_DEPLOY.md for full details"
+

get_refresh_token.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""
+Helper script for retrieving a Google Drive refresh token.
+
+Run it once, finish the OAuth flow, then copy the printed token into
+REFRESH_TOKEN inside google_drive_sync.py.
+
+If you hit an invalid_client error, consider switching to the Service
+Account approach, which is more reliable.
+"""
+
+from google_drive_sync import get_refresh_token
+
+if __name__ == "__main__":
+    print("="*60)
+    print("Google Drive Refresh Token Helper")
+    print("="*60)
+    print("\n⚠️  If you see 'invalid_client', the OAuth client is misconfigured.")
+    print("   Use the Service Account method instead (no OAuth required).")
+    print("   See google_drive_setup_guide.md for the full walkthrough.\n")
+    print("A browser window will open so you can complete Google sign-in...\n")
+    
+    refresh_token = get_refresh_token()
+    
+    if refresh_token:
+        print("\n✅ Success! Copy the refresh_token above into google_drive_sync.py.")
+    else:
+        print("\n" + "="*60)
+        print("❌ Failed to get refresh_token")
+        print("="*60)
+        print("\nPossible fixes:")
+        print("1. Use a Service Account (recommended):")
+        print("   - See option B in google_drive_setup_guide.md")
+        print("   - Create a Service Account and download the JSON key")
+        print("   - Set SERVICE_ACCOUNT_FILE inside google_drive_sync.py")
+        print("\n2. Create a new OAuth client:")
+        print("   - Visit https://console.cloud.google.com/")
+        print("   - Create a new OAuth 2.0 client ID")
+        print("   - Update CLIENT_ID and CLIENT_SECRET in google_drive_sync.py")
+        print("="*60)
+

google_drive_setup_guide.md

@@ -0,0 +1,117 @@
+# Google Drive Hard-Coded Auth Guide
+
+Use this guide to enable automatic Drive uploads without running OAuth each time.
+
+## Option 1: Refresh Token (recommended, simple)
+
+### Step 1: Obtain a refresh token
+
+1. In a Python shell run:
+
+```python
+from google_drive_sync import get_refresh_token
+refresh_token = get_refresh_token()
+```
+
+2. A browser window opens for Google sign-in
+3. The terminal prints your `refresh_token`, e.g.
+   ```
+   REFRESH_TOKEN = "1//0gxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+   ```
+
+### Step 2: Configure the refresh token
+
+Open `google_drive_sync.py` and set:
+
+```python
+REFRESH_TOKEN = None  # place your refresh token here
+```
+
+Replace `None` with your token:
+
+```python
+REFRESH_TOKEN = "1//0gxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # your refresh token
+```
+
+### Step 3: Done
+
+Save the file; future uploads happen automatically without another login.
+
+---
+
+## Option 2: Service Account (more secure, production-friendly)
+
+### Step 1: Create the Service Account
+
+1. Visit [Google Cloud Console](https://console.cloud.google.com/)
+2. Select or create a project
+3. Enable the Google Drive API
+4. Go to “IAM & Admin” → “Service Accounts”
+5. Click “Create Service Account”
+6. Provide a name/description, click “Create and Continue”
+7. Grant the “Editor” role, then “Continue” → “Done”
+
+### Step 2: Create and download the key
+
+1. Open the Service Account
+2. Go to the “Keys” tab
+3. Click “Add Key” → “Create new key”
+4. Choose JSON → “Create”
+5. Save the JSON into your project directory (e.g., `service-account-key.json`)
+
+### Step 3: Share the Drive folder with the Service Account
+
+1. Create a folder in Drive (e.g., “Chatbot_Data”)
+2. Right-click → “Share”
+3. In the JSON file find `client_email` (looks like `xxx@xxx.iam.gserviceaccount.com`)
+4. Add that email to the folder with “Editor” access
+
+### Step 4: Point the code to the Service Account file
+
+Set this in `google_drive_sync.py`:
+
+```python
+SERVICE_ACCOUNT_FILE = None  # e.g. "path/to/service-account-key.json"
+```
+
+Replace `None` with your JSON path:
+
+```python
+SERVICE_ACCOUNT_FILE = "service-account-key.json"  # your Service Account JSON path
+```
+
+### Step 5: Done
+
+All data now syncs to the folder you shared with the Service Account!
+
+---
+
+## Verify the setup
+
+Run the app and confirm uploads reach Drive. If not, check:
+
+1. Refresh token or Service Account path is correct
+2. Network connectivity
+3. Google Drive API is enabled
+4. Service Account has access to the folder
+
+## Notes
+
+⚠️ **Security reminders**
+- Never commit credentials to public repos
+- Add `google_drive_sync.py` or secrets to `.gitignore` if needed
+- Protect the Service Account JSON carefully
+
+## Troubleshooting
+
+### Refresh token expired
+Re-run `get_refresh_token()` to obtain a new one.
+
+### Service Account can’t access the folder
+Ensure the Service Account email was invited with the proper permission.
+
+### Authentication failure
+1. Double-check `CLIENT_ID` / `CLIENT_SECRET`
+2. Confirm the Drive API is enabled
+3. Verify your network connection
+

google_drive_sync.py

@@ -5,6 +5,7 @@ from datetime import datetime
 
 from google.auth.transport.requests import Request
 from google.oauth2.credentials import Credentials
+from google.oauth2 import service_account
 from google_auth_oauthlib.flow import InstalledAppFlow
 from googleapiclient.discovery import build
 from googleapiclient.http import MediaFileUpload
@@ -12,16 +13,33 @@ from googleapiclient.http import MediaFileUpload
 # Google Drive API scopes
 SCOPES = ['https://www.googleapis.com/auth/drive.file']
 
+# ============================================================================
+# Hard-coded Google Drive auth configuration
+# Option 1: Service Account (recommended)
+# Option 2: Refresh Token
+# ============================================================================
+
+# Option 1: Service Account JSON file (env-var friendly for Spaces)
+SERVICE_ACCOUNT_FILE = os.getenv("GOOGLE_SERVICE_ACCOUNT_FILE", None)  # e.g. "path/to/service-account-key.json"
+
+# Option 2: Refresh Token (requires OAuth flow once)
+REFRESH_TOKEN = os.getenv("GOOGLE_REFRESH_TOKEN", None)
+CLIENT_ID = os.getenv("GOOGLE_CLIENT_ID")
+CLIENT_SECRET = os.getenv("GOOGLE_CLIENT_SECRET")
+
+# Fallback: interactive OAuth
+USE_HARDCODED_AUTH = SERVICE_ACCOUNT_FILE is not None or REFRESH_TOKEN is not None
+
 # Real OAuth 2.0 configuration - Public client credentials for this app
 # These are safe to include in public code (they're meant to be public)
 CLIENT_CONFIG = {
     "installed": {
-        "client_id": "764086051850-6qr4p6gpi6hn506pt8ejuq83di341hur.apps.googleusercontent.com",
+        "client_id": CLIENT_ID,
         "project_id": "patient-eval-app-439620",
         "auth_uri": "https://accounts.google.com/o/oauth2/auth",
         "token_uri": "https://oauth2.googleapis.com/token",
         "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
-        "client_secret": "d-FL95Q19q7MQmFpd7hPD0Ty",
+        "client_secret": CLIENT_SECRET,
         "redirect_uris": ["http://localhost"]
     }
 }
@@ -55,10 +73,56 @@ class GoogleDriveSync:
             return False, f"Authentication error: {str(e)}"
     
     def authenticate(self):
-        """Authenticate with existing token or start new flow"""
+        """Authenticate with hardcoded credentials, existing token, or start new flow"""
         creds = None
         
-        # Load existing token
+        # Option 1: Service Account (supports env JSON for Spaces)
+        service_account_json = os.getenv("GOOGLE_SERVICE_ACCOUNT_JSON")
+        if service_account_json:
+            try:
+                import tempfile
+                import json as json_lib
+                # Persist JSON string to a temporary file
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+                    json_lib.dump(json_lib.loads(service_account_json), f)
+                    temp_file = f.name
+                creds = service_account.Credentials.from_service_account_file(
+                    temp_file, scopes=SCOPES)
+                self.service = build('drive', 'v3', credentials=creds)
+                os.unlink(temp_file)  # remove temp file
+                return True, "Authenticated with Service Account (from env)"
+            except Exception as e:
+                return False, f"Service Account authentication error: {str(e)}"
+        
+        if SERVICE_ACCOUNT_FILE and os.path.exists(SERVICE_ACCOUNT_FILE):
+            try:
+                creds = service_account.Credentials.from_service_account_file(
+                    SERVICE_ACCOUNT_FILE, scopes=SCOPES)
+                self.service = build('drive', 'v3', credentials=creds)
+                return True, "Authenticated with Service Account"
+            except Exception as e:
+                return False, f"Service Account authentication error: {str(e)}"
+        
+        # Option 2: hard-coded refresh token
+        if REFRESH_TOKEN:
+            if not CLIENT_ID or not CLIENT_SECRET:
+                return False, "Refresh token provided but GOOGLE_CLIENT_ID / GOOGLE_CLIENT_SECRET are missing."
+            try:
+                creds = Credentials(
+                    token=None,
+                    refresh_token=REFRESH_TOKEN,
+                    token_uri="https://oauth2.googleapis.com/token",
+                    client_id=CLIENT_ID,
+                    client_secret=CLIENT_SECRET
+                )
+                # Refresh to obtain a fresh access token
+                creds.refresh(Request())
+                self.service = build('drive', 'v3', credentials=creds)
+                return True, "Authenticated with Refresh Token"
+            except Exception as e:
+                return False, f"Refresh Token authentication error: {str(e)}"
+        
+        # Option 3: previously saved token file
         if os.path.exists(self.token_file):
             try:
                 with open(self.token_file, 'rb') as token:
@@ -259,4 +323,60 @@ def check_user_authentication(user_id="default"):
     """Check if user is already authenticated"""
     sync = get_user_sync(user_id)
     success, message = sync.authenticate()
-    return success, message
+    return success, message
+
+def get_refresh_token():
+    """
+    Helper: run once to fetch a refresh token for the hard-coded config.
+    Complete the OAuth flow, copy the printed token into REFRESH_TOKEN.
+    """
+    try:
+        flow = InstalledAppFlow.from_client_config(CLIENT_CONFIG, SCOPES)
+        creds = flow.run_local_server(port=0, open_browser=True)
+        
+        if creds and creds.refresh_token:
+            print("\n" + "="*60)
+            print("✅ Refresh token retrieved!")
+            print("="*60)
+            print(f"\nPaste the following refresh_token into REFRESH_TOKEN:\n")
+            print(f"REFRESH_TOKEN = \"{creds.refresh_token}\"")
+            print("\n" + "="*60 + "\n")
+            return creds.refresh_token
+        else:
+            print("❌ Could not obtain refresh_token. Please retry.")
+            return None
+    except Exception as e:
+        print(f"❌ Error retrieving refresh_token: {str(e)}")
+        return None
+
+def auto_upload_to_drive(file_path, user_id="default", folder_name="Chatbot_Data"):
+    """
+    Automatically upload a file to Google Drive if user is authenticated.
+    Returns (success, message) tuple. If not authenticated, returns (False, None) silently.
+    This function fails silently to not interrupt normal operation.
+    """
+    try:
+        sync = get_user_sync(user_id)
+        
+        # Check authentication (uses hard-coded creds if configured)
+        success, message = sync.authenticate()
+        if not success:
+            # Log once when hard-coded auth was expected but failed
+            if USE_HARDCODED_AUTH:
+                print(f"⚠️ Google Drive authentication failed: {message}")
+            return False, None  # Not authenticated, fail silently
+        
+        # Create or get folder (use custom folder name for chatbot data)
+        folder_id, folder_message = sync.create_or_get_folder(folder_name)
+        if not folder_id:
+            return False, None  # Fail silently if folder creation fails
+        
+        # Upload file
+        success, result = sync.upload_file(file_path)
+        if success:
+            return True, f"✅ Auto-uploaded to Google Drive: {result.get('name', 'file')}"
+        else:
+            return False, None  # Fail silently on upload error
+    except Exception as e:
+        # Fail silently if there's an error (e.g., network issue, import error)
+        return False, None

src/server.py

@@ -232,6 +232,20 @@ def configure_routes(app, args):
             # save memory graph
             server.doctor.memory_graph.save(local_memory_graph_file)
         
+        # Auto-upload to Google Drive if authenticated
+        try:
+            import sys
+            sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+            from google_drive_sync import auto_upload_to_drive
+            
+            # Upload conversation file
+            auto_upload_to_drive(local_conv_file_path, user_id=username, folder_name="Chatbot_Conversations")
+            # Upload memory graph file
+            auto_upload_to_drive(local_memory_graph_file, user_id=username, folder_name="Chatbot_Conversations")
+        except Exception as e:
+            # Fail silently if Google Drive upload fails
+            print(f"Google Drive auto-upload failed (non-critical): {str(e)}")
+        
         return jsonify({"message": "Current conversation and memory graph are saved!"}), 200
 
     @app.route('/responses/doctor', methods=['POST'])