HF Space Docker

Dockerfile

@@ -0,0 +1,36 @@
+# ───────────────────────────────────────────────
+# MindPalace AI – Hugging Face Spaces (Docker)
+# ───────────────────────────────────────────────
+# • CPU-only base image with Python 3.11
+# • Installs system libs (tesseract, ffmpeg) needed by OCR / audio
+# • Installs Python dependencies from requirements.txt
+# • Runs Gunicorn with gevent workers on HF-required port 7860
+# • Space URL will be: https://<handle>-MindPalaceAI.hf.space
+# ───────────────────────────────────────────────
+
+FROM python:3.11-slim
+
+# 1️⃣  Install system packages (add more as you need)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        tesseract-ocr \
+        libgl1 \
+        ffmpeg && \
+    rm -rf /var/lib/apt/lists/*
+
+# 2️⃣  Set work directory
+WORKDIR /app
+
+# 3️⃣  Copy & install Python deps first (layer cache)
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 4️⃣  Copy the rest of the application code
+COPY . .
+
+# 5️⃣  Hugging Face automatically sets $PORT=7860
+ENV PORT=7860
+EXPOSE ${PORT}
+
+# 6️⃣  Start the server
+CMD ["gunicorn", "wsgi:app", "-k", "gevent", "--timeout", "300", "--bind", "0.0.0.0:${PORT}"]

app/__init__.py

@@ -0,0 +1,7 @@
+from flask import Flask
+from app.routes import bp
+
+def create_app():
+    app = Flask(__name__)
+    app.register_blueprint(bp)
+    return app

app/config.py

@@ -0,0 +1,12 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class Config:
+    FIREWORKS_API_KEY = os.getenv("FIREWORKS_API_KEY")
+    WHISPER_MODEL = os.getenv("WHISPER_MODEL")
+    SENTIMENT_MODEL = os.getenv("SENTIMENT_MODEL")
+    EMOTION_MODEL = os.getenv("EMOTION_MODEL")
+    YOLO_MODEL = os.getenv("YOLO_MODEL")

app/models.py

@@ -0,0 +1,26 @@
+import whisper
+import torch
+from transformers import pipeline
+from fireworks.client import Fireworks
+from app.config import Config
+
+# 🔹 Load AI Models
+audio_model = whisper.load_model(Config.WHISPER_MODEL)
+# 1. Specialized Sentiment Model (Direct Labeling)
+sentiment_pipeline = pipeline(
+    "text-classification",
+    model="cardiffnlp/twitter-roberta-base-sentiment-latest",
+    return_all_scores=False
+)
+
+# 2. Focused Emotion Model (Single Emotion)
+emotion_pipeline = pipeline(
+    "text-classification",
+    model="j-hartmann/emotion-english-distilroberta-base",
+    top_k=1
+)
+
+#yolo_model = torch.hub.load(Config.YOLO_MODEL, 'yolov5s')
+
+# 🔹 Initialize Fireworks AI Client
+client = Fireworks(api_key=Config.FIREWORKS_API_KEY)

app/routes.py

@@ -0,0 +1,172 @@
+from flask import Blueprint, request, jsonify
+from werkzeug.utils import secure_filename
+import os
+import easyocr
+import pytesseract  # Ensure this is imported
+from PIL import Image
+from app.models import audio_model, sentiment_pipeline, emotion_pipeline
+from app.services import extract_tasks
+from app.utils import generate_tags, error_response
+
+# Initialize Flask Blueprint
+bp = Blueprint('main', __name__)
+
+# Initialize the EasyOCR reader for English only (disable GPU if not available)
+reader = easyocr.Reader(['en'], gpu=False)
+
+EMOTION_SCORE_THRESHOLD = 0.15  # Adjust based on your testing
+MIN_SENTIMENT_CONFIDENCE = 0.4  # Below this becomes "neutral"
+
+# =============================
+# 🔹 API Routes
+# =============================
+
+@bp.route('/transcribe', methods=['POST'])
+def transcribe():
+    if 'file' not in request.files:
+        return error_response("No file provided", 400)
+
+    file = request.files['file']
+    file_path = os.path.join("/tmp", secure_filename(file.filename))
+    file.save(file_path)
+
+    try:
+        # Transcribe Audio
+        result = audio_model.transcribe(file_path)
+        transcription = result.get("text", "")
+
+        if not transcription.strip():
+            return error_response("Transcription is empty", 400)
+
+        # Send transcription to /analyze_text API
+        analysis_response = analyze_text_internal(transcription)
+        tags = generate_tags(transcription)  # Function to extract tags from text
+
+        return jsonify({
+            "transcription": transcription,
+            "sentiment": analysis_response["sentiment"],
+            "emotion": analysis_response["emotion"],
+            "confidence": analysis_response["confidence"],
+            "tags": tags
+        })
+    except Exception as e:
+        return error_response(str(e), 500)
+
+
+@bp.route('/analyze_image', methods=['POST'])
+def analyze_image():
+    if 'file' not in request.files:
+        return error_response("No image file provided", 400)
+
+    file = request.files['file']
+    filename = secure_filename(file.filename)
+    file_path = os.path.join("/tmp", filename)
+    file.save(file_path)
+
+    try:
+        # Use EasyOCR in detail mode to get confidence scores
+        results = reader.readtext(file_path, detail=1)
+
+        # Filter out entries with low confidence (e.g., below 0.5)
+        filtered_texts = [text for bbox, text, conf in results if conf > 0.5]
+        extracted_text = "\n".join(filtered_texts)
+
+        print("Filtered Extracted text:", extracted_text)
+
+        if not extracted_text.strip():
+            return error_response("No meaningful text found in image", 400)
+
+        # Analyze the extracted text to get sentiment, emotion, etc.
+        analysis_response = analyze_text_internal(extracted_text)
+        tags = generate_tags(extracted_text)
+
+        return jsonify({
+            "extracted_text": extracted_text.strip(),
+            "sentiment": analysis_response.get("sentiment"),
+            "emotion": analysis_response.get("emotion"),
+            "confidence": analysis_response.get("confidence"),
+            "tags": tags
+        })
+    except Exception as e:
+        return error_response(str(e), 500)
+
+
+# Internal function to call analyze_text directly
+def analyze_text_internal(text):
+    try:
+        # Get sentiment (positive/neutral/negative)
+        sentiment = sentiment_pipeline(text)[0]
+
+        # Get dominant emotion (anger/disgust/fear/joy/neutral/sadness/surprise)
+        emotion = emotion_pipeline(text)[0][0]
+
+        return {
+            "sentiment": sentiment['label'],
+            "emotion": emotion['label'],
+            "confidence": {
+                "sentiment": round(sentiment['score'], 3),
+                "emotion": round(emotion['score'], 3)
+            }
+        }
+    except Exception as e:
+        print(f"Analysis error: {str(e)}")
+        return error_response(f"Processing error: {str(e)}", 500)
+
+
+@bp.route('/analyze_text', methods=['POST'])
+def analyze_text():
+    data = request.json
+    if not data or 'text' not in data:
+        return error_response("No text provided", 400)
+
+    text = data['text'].strip().lower()
+
+    try:
+        # Get sentiment (positive/neutral/negative)
+        sentiment = sentiment_pipeline(text)[0]
+
+        # Get dominant emotion (anger/disgust/fear/joy/neutral/sadness/surprise)
+        emotion = emotion_pipeline(text)[0][0]
+
+        tags = generate_tags(text)
+
+        return {
+            "sentiment": sentiment['label'],
+            "emotion": emotion['label'],
+            "confidence": {
+                "sentiment": round(sentiment['score'], 3),
+                "emotion": round(emotion['score'], 3)
+            },
+            "tags": tags
+        }
+    except Exception as e:
+        print(f"Analysis error: {str(e)}")
+        return error_response(f"Processing error: {str(e)}", 500)
+
+
+# 📌 3. Extract Actionable Tasks
+@bp.route('/extract_actions', methods=['POST'])
+def extract_actions():
+    data = request.json
+    if not data or 'text' not in data:
+        return error_response("No text provided", 400)
+
+    text = data['text']
+    try:
+        tasks = extract_tasks(text)
+        return jsonify({"tasks": tasks})
+    except Exception as e:
+        return error_response(str(e), 500)
+
+
+# =============================
+# 🔹 Error Handling
+# =============================
+
+@bp.errorhandler(404)
+def not_found_error(error):
+    return error_response("Not Found", 404)
+
+@bp.errorhandler(500)
+def internal_error(error):
+    return error_response("Internal Server Error", 500)

app/services.py

@@ -0,0 +1,42 @@
+import json
+from app.models import client
+from datetime import datetime
+
+# 🔹 Extract Actionable Tasks
+def extract_tasks(text):
+    today_date = datetime.today().strftime("%Y-%m-%d")
+
+    response = client.chat.completions.create(
+        model="accounts/fireworks/models/llama-v3p1-8b-instruct",
+        messages=[
+            {
+                "role": "system",
+                "content": (
+                    f"You are a task extraction assistant. Today's date is **{today_date}**.\n"
+                    "Your goal is to extract **exactly 2** actionable tasks from the given text.\n"
+                    "Each task must have:\n"
+                    "- A **title** (short summary of the task)\n"
+                    "- A **dueDate** in `YYYY-MM-DD` format (Convert words like 'tomorrow', 'next week' into actual dates based on today's date)\n\n"
+                    "Return **ONLY valid JSON** with this format:\n"
+                    "{\n"
+                    '  "tasks": [\n'
+                    '    {\n'
+                    '      "title": "Task description",\n'
+                    '      "dueDate": "YYYY-MM-DD"  # Always absolute date\n'
+                    "    }\n"
+                    "  ]\n"
+                    "}"
+                ),
+            },
+            {"role": "user", "content": text},
+        ],
+        max_tokens=200,
+    )
+
+    # Ensure response is valid JSON
+    try:
+        model_output = response.choices[0].message.content.strip()
+        parsed_response = json.loads(model_output)
+        return parsed_response.get("tasks", [])
+    except json.JSONDecodeError:
+        return []

app/utils.py

@@ -0,0 +1,50 @@
+import json
+from flask import jsonify
+
+# 🔹 Generate Tags from Text
+def generate_tags(content):
+    stop_words = {"the", "and", "is", "in", "to", "a", "of", "on", "for"}
+    words = content.lower().split()
+    tags = [word for word in words if word not in stop_words and len(word) > 3]
+    return list(set(tags))
+
+# 🔹 Parse JSON Responses
+def parse_json(response):
+    try:
+        return json.loads(response)
+    except json.JSONDecodeError:
+        return None
+
+# 🔹 Error Handlers
+def error_response(message, status_code):
+    return jsonify({"error": message}), status_code
+
+# Update emotion categorization mapping
+EMOTION_CATEGORIES = {
+    "goal-oriented": ["desire", "anticipation", "optimism"],
+    "social": ["gratitude", "admiration", "love"],
+    "reflective": ["remorse", "sadness", "disappointment"],
+    "urgent": ["fear", "nervousness", "surprise"],
+    "critical": ["anger", "disgust", "annoyance"],
+    "joyful": ["joy", "excitement", "amusement"]
+}
+
+SENTIMENT_MAP = {
+    "LABEL_0": "negative",
+    "LABEL_1": "neutral",
+    "LABEL_2": "positive"
+}
+
+def categorize_memory(emotions, sentiment):
+    """Improved categorization with fallback logic"""
+    if not emotions:
+        return f"uncategorized-{sentiment['label']}"
+
+    # Find direct matches
+    for emotion in emotions:
+        for category, keywords in EMOTION_CATEGORIES.items():
+            if emotion['label'] in keywords:
+                return f"{category}-{sentiment['label']}"
+
+    # Fallback to sentiment-based category
+    return f"neutral-{sentiment['label']}"

requirements.txt

@@ -0,0 +1,90 @@
+accelerate==1.3.0
+annotated-types==0.7.0
+anyio==4.8.0
+blinker==1.9.0
+certifi==2024.12.14
+charset-normalizer==3.4.1
+click==8.1.8
+contourpy==1.3.1
+cycler==0.12.1
+easyocr==1.7.2
+exceptiongroup==1.2.2
+filelock==3.16.1
+fireworks-ai==0.15.12
+Flask==3.1.0
+fonttools==4.55.6
+fsspec==2024.12.0
+gevent==25.4.2
+gitdb==4.0.12
+GitPython==3.1.44
+greenlet==3.2.1
+gunicorn==23.0.0
+h11==0.14.0
+httpcore==1.0.7
+httpx==0.28.1
+httpx-sse==0.4.0
+httpx-ws==0.7.1
+huggingface-hub==0.27.1
+idna==3.10
+imageio==2.37.0
+itsdangerous==2.2.0
+Jinja2==3.1.5
+kiwisolver==1.4.8
+lazy_loader==0.4
+llvmlite==0.44.0
+MarkupSafe==3.0.2
+matplotlib==3.10.0
+mistral_inference==1.5.0
+more-itertools==10.6.0
+mpmath==1.3.0
+networkx==3.4.2
+ninja==1.11.1.3
+numba==0.61.0
+numpy==1.24.4
+openai-whisper==20240930
+opencv-python==4.11.0.86
+opencv-python-headless==4.11.0.86
+packaging==24.2
+pandas==2.2.3
+pillow==11.1.0
+psutil==6.1.1
+py-cpuinfo==9.0.0
+pyclipper==1.3.0.post6
+pydantic==2.10.6
+pydantic_core==2.27.2
+pyparsing==3.2.1
+pytesseract==0.3.13
+python-bidi==0.6.3
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+pytz==2024.2
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.3
+safetensors==0.5.2
+scikit-image==0.25.1
+scipy==1.15.1
+seaborn==0.13.2
+sentencepiece==0.2.0
+shapely==2.0.7
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+sympy==1.13.1
+tifffile==2025.1.10
+tiktoken==0.8.0
+tokenizers==0.21.0
+torch==2.5.1
+torchaudio==2.5.1
+torchvision==0.20.1
+tqdm==4.67.1
+transformers==4.48.1
+typing_extensions==4.12.2
+tzdata==2025.1
+ultralytics==8.3.67
+ultralytics-thop==2.0.14
+urllib3==2.3.0
+Werkzeug==3.1.3
+wsproto==1.2.0
+zope.event==5.0
+zope.interface==7.2

wsgi.py

@@ -0,0 +1,2 @@
+from app import create_app        # or simply `from app import app`
+app = create_app()