Update app.py

app.py

@@ -1,13 +1,15 @@
-# JusticeAI Backend — Improved Version (Backend-only, ready to deploy)
+# JusticeAI Backend — Ready to Deploy (Hugging Face Spaces & General Use)
 #
 # Improvements:
-# 1. Leaderboard only shows refined ('learned') knowledge, never user chat/memory.
-# 2. Replies are always synthesized in English first, then translated to user language if needed.
-# 3. Synthesis logic enhanced: combines knowledge, LLM inspiration, intent, context, asks for clarification if uncertain.
-# 4. User chat/memory is never used for global replies or leaderboard.
-# 5. All endpoints preserved and improved.
+# - Translation cache set to /tmp/translation_models for Hugging Face Spaces.
+# - No hardcoded replies/branding; knowledge-based/context-aware responses only.
+# - Replies always synthesized in English and translated to user language at the final step.
+# - Deduplication of sentences for uniqueness; language mismatch prevented.
+# - Local LLM is now google/gemma-2b (small, fast, English chat).
+# - Graceful fallback if LLM not available.
+# - Leaderboard only from refined knowledge; user chat/memory never used for global answers.
+# - All endpoints preserved and improved.
 
-from sqlalchemy.pool import NullPool
 import os
 import time
 import json
@@ -18,7 +20,6 @@ import asyncio
 import re
 from datetime import datetime, timezone
 from collections import deque
-from pathlib import Path
 from typing import Optional, Dict, Any, List
 
 import requests
@@ -26,33 +27,43 @@ import psutil
 import torch
 import uvicorn
 from fastapi import FastAPI, Request, Body, Header, Query
-from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse, FileResponse
+from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
 from sqlalchemy import create_engine, text as sql_text
+from sqlalchemy.pool import NullPool
 
 import logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("justiceai")
 
-# ----- Environment & cache directories -----
-HF_CACHE_DIR = os.environ.get("HF_HOME", "/tmp/huggingface")
-os.environ["HF_HOME"] = HF_CACHE_DIR
-os.environ["TRANSFORMERS_CACHE"] = HF_CACHE_DIR
-os.environ["SENTENCE_TRANSFORMERS_HOME"] = HF_CACHE_DIR
+# Translation cache for Hugging Face Spaces
+TRANSLATION_CACHE_DIR = os.environ.get("TRANSLATION_CACHE_DIR", "/tmp/translation_models")
+os.environ["TRANSLATION_CACHE_DIR"] = TRANSLATION_CACHE_DIR
+
+# Config
+ADMIN_KEY = os.environ.get("ADMIN_KEY")
+DATABASE_URL = os.environ.get("DATABASE_URL", "sqlite:///justice.db")
+EMBED_MODEL_NAME = os.environ.get("EMBED_MODEL_NAME", "paraphrase-multilingual-MiniLM-L12-v2")
+LLM_MODEL_PATH = os.environ.get("LLM_MODEL_PATH", "google/gemma-2b")
+SAVE_MEMORY_CONFIDENCE = float(os.environ.get("SAVE_MEMORY_CONFIDENCE", "0.45"))
 
-# ----- Optional helpers (soft fallbacks) -----
+app = FastAPI(title="JusticeAI — Backend (final)")
+engine = create_engine(
+    DATABASE_URL,
+    poolclass=NullPool,
+    connect_args={"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {}
+)
+
+# Optional helpers (soft fallbacks)
 try:
     from emojis import get_emoji, get_category_for_mood
 except Exception:
-    def get_category_for_mood(mood: str) -> str:
-        return "neutral"
-    def get_emoji(cat: str, intensity: float = 0.5) -> str:
-        return "🤖"
+    def get_category_for_mood(mood: str) -> str: return "neutral"
+    def get_emoji(cat: str, intensity: float = 0.5) -> str: return "🤖"
 
 try:
     from health import get_health_status
 except Exception:
-    def get_health_status(engine_arg) -> Dict[str, Any]:
-        return {"status": "starting", "db_status": "unknown", "stars": 0}
+    def get_health_status(engine_arg) -> Dict[str, Any]: return {"status": "starting", "db_status": "unknown", "stars": 0}
 
 try:
     from langdetect import detect as detect_lang
@@ -77,22 +88,7 @@ except Exception:
     AutoModelForCausalLM = None
     hf_pipeline = None
 
-# ----- Config (env) -----
-ADMIN_KEY = os.environ.get("ADMIN_KEY")
-DATABASE_URL = os.environ.get("DATABASE_URL", "sqlite:///justice.db")
-EMBED_MODEL_NAME = os.environ.get("EMBED_MODEL_NAME", "paraphrase-multilingual-MiniLM-L12-v2")
-TRANSLATION_CACHE_DIR = os.environ.get("TRANSLATION_CACHE_DIR", "./translation_models")
-LLM_MODEL_PATH = os.environ.get("LLM_MODEL_PATH", "")  # path to local LLM (optional)
-SAVE_MEMORY_CONFIDENCE = float(os.environ.get("SAVE_MEMORY_CONFIDENCE", "0.45"))
-
-app = FastAPI(title="JusticeAI — Backend (improved)")
-engine = create_engine(
-    DATABASE_URL,
-    poolclass=NullPool,
-    connect_args={"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {}
-)
-
-# ----- Ensure DB schema -----
+# ===== Database Table Creation =====
 def ensure_tables():
     dialect = engine.dialect.name
     with engine.begin() as conn:
@@ -162,7 +158,6 @@ def ensure_tables():
                 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                 updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
             );"""))
-
 ensure_tables()
 
 def ensure_column_exists(table: str, column: str, col_def_sql: str):
@@ -170,18 +165,12 @@ def ensure_column_exists(table: str, column: str, col_def_sql: str):
     try:
         with engine.begin() as conn:
             if dialect == "sqlite":
-                try:
-                    rows = conn.execute(sql_text(f"PRAGMA table_info({table})")).fetchall()
-                    existing_cols = [r[1] for r in rows]
-                    if column not in existing_cols:
-                        conn.execute(sql_text(f"ALTER TABLE {table} ADD COLUMN {col_def_sql}"))
-                except Exception:
-                    pass
+                rows = conn.execute(sql_text(f"PRAGMA table_info({table})")).fetchall()
+                existing_cols = [r[1] for r in rows]
+                if column not in existing_cols:
+                    conn.execute(sql_text(f"ALTER TABLE {table} ADD COLUMN {col_def_sql}"))
             else:
-                try:
-                    conn.execute(sql_text(f"ALTER TABLE {table} ADD COLUMN IF NOT EXISTS {col_def_sql}"))
-                except Exception:
-                    pass
+                conn.execute(sql_text(f"ALTER TABLE {table} ADD COLUMN IF NOT EXISTS {col_def_sql}"))
     except Exception:
         pass
 
@@ -190,7 +179,7 @@ ensure_column_exists("user_memory", "reply", "reply TEXT")
 ensure_column_exists("knowledge", "language", "language TEXT DEFAULT 'en'")
 ensure_column_exists("knowledge", "embedding", "embedding BYTEA" if engine.dialect.name != "sqlite" else "embedding BLOB")
 
-# ----- State & metrics -----
+# ===== State & Metrics =====
 app_start_time = time.time()
 last_heartbeat = {"time": datetime.utcnow().replace(tzinfo=timezone.utc).isoformat(), "ok": True}
 RECENT_WINDOW_SECONDS = 3600
@@ -221,10 +210,9 @@ moderator = None
 llm_tokenizer = None
 llm_model = None
 startup_time = 0.0
-
 _translation_model_cache: Dict[str, Any] = {}
 
-# ----- Helpers -----
+# ===== Helpers =====
 def record_request(duration_s: float):
     global response_time_ema
     ts = time.time()
@@ -377,19 +365,8 @@ def embed_text(text_data: str) -> bytes:
         logger.warning(f"Embedding fallback: {e}")
         raise
 
-# Boilerplate detection + creative reply generation
 def is_boilerplate_candidate(s: str) -> bool:
-    s_low = (s or "").strip().lower()
-    generic_phrases = [
-        "justiceai is a unified intelligence dashboard providing chat, knowledge, and live metrics.",
-        "justiceai es un panel de inteligencia unificado que proporciona chat, conocimiento y métricas en vivo."
-    ]
-    for g in generic_phrases:
-        if s_low == g.strip().lower():
-            return True
-        if g.split(" ")[0].lower() in s_low and len(s_low) < 90:
-            return True
-    return False
+    return False  # Remove all branding/boilerplate logic
 
 def generate_creative_reply(matches: List[str]) -> str:
     clean = []
@@ -401,10 +378,9 @@ def generate_creative_reply(matches: List[str]) -> str:
         seen.add(s)
         clean.append(s)
     if not clean:
-        return "I’m not sure yet."
+        return "Can you provide more details so I can help better?"
     if len(clean) == 1:
         return clean[0]
-    # Return a concise, combined statement
     joined = ". ".join(clean[:3])
     return joined
 
@@ -427,10 +403,6 @@ def infer_topic_from_message(msg: str, known_topics=None) -> str:
         return "general"
 
 def refine_or_update(matches, new_text, new_reply, confidence, topic="general"):
-    """
-    Decide whether to update existing knowledge or insert a new entry based on similarity.
-    Uses embed_model to compare and updates DB accordingly.
-    """
     try:
         if embed_model is None:
             return
@@ -479,31 +451,21 @@ def detect_mood(text: str) -> str:
     return "neutral"
 
 def synthesize_final_reply(en_msg: str, matches: List[str], llm_suggestion: str, intent: str) -> str:
-    """
-    Central decision function: combine matches and llm_suggestion but JusticeAI always decides final text.
-    Rules:
-      - Only use knowledge marked as 'learned' (refined).
-      - If a direct high-confidence match exists, prefer it.
-      - Else combine top matches into meaningful synthesis.
-      - If LLM suggestion exists, use it as additional candidate but do not accept it verbatim;
-        instead, extract/merge useful sentences with knowledge matches.
-      - Apply intent-specific formatting at the end.
-      - If nothing is found, ask for clarification.
-    """
     pieces = []
     for m in matches:
-        if m and not is_boilerplate_candidate(m):
-            pieces.append(dedupe_sentences(m))
+        if m:
+            deduped = dedupe_sentences(m)
+            if deduped not in pieces:
+                pieces.append(deduped)
     if llm_suggestion:
-        # extract some sentences from the suggestion (avoid hallucinated facts)
-        s = dedupe_sentences(llm_suggestion)
-        for sent in re.split(r'(?<=[.?!])\s+', s):
-            if len(sent.split()) < 60 and sent and sent not in pieces:
+        llm_sentences = re.split(r'(?<=[.?!])\s+', dedupe_sentences(llm_suggestion))
+        for sent in llm_sentences:
+            if sent and sent not in pieces and len(sent.split()) < 60:
                 pieces.append(sent)
     if not pieces:
         return "Can you provide more details so I can help better?"
     reply = ". ".join(pieces[:3])
-    # Intent postprocessing
+    # Intent formatting
     if intent == "solution":
         bullets = [p.strip(" .") for p in re.split(r'\.\s+', reply) if p.strip()]
         pref = "Solutions:\n- "
@@ -517,14 +479,11 @@ def synthesize_final_reply(en_msg: str, matches: List[str], llm_suggestion: str,
         reply = reply
     return reply
 
-# ----- Startup: load models & background loops -----
 @app.on_event("startup")
 async def startup_event():
     global embed_model, spell, moderator, llm_tokenizer, llm_model, startup_time
     t0 = time.time()
     logger.info("[JusticeAI] Starting component loading...")
-
-    # Embedding model
     try:
         if SentenceTransformer is not None:
             embed_model = SentenceTransformer(EMBED_MODEL_NAME, device="cpu")
@@ -539,8 +498,6 @@ async def startup_event():
         embed_model = None
         model_progress["embed"]["status"] = "error"
         logger.warning(f"[JusticeAI] Failed to load embedding model: {e}")
-
-    # Spell checker
     try:
         if SpellChecker is not None:
             spell = SpellChecker()
@@ -555,8 +512,6 @@ async def startup_event():
         spell = None
         model_progress["spell"]["status"] = "error"
         logger.warning(f"[JusticeAI] SpellChecker load failed: {e}")
-
-    # Moderator pipeline
     try:
         if AutoTokenizer is not None and hf_pipeline is not None:
             moderator = hf_pipeline("text-classification", model="unitary/toxic-bert", device=-1)
@@ -571,12 +526,11 @@ async def startup_event():
         moderator = None
         model_progress["moderator"]["status"] = "error"
         logger.warning(f"[JusticeAI] Moderator load error: {e}")
-
-    # Local LLM for background learning/inspiration
     try:
-        if LLM_MODEL_PATH and AutoTokenizer is not None and AutoModelForCausalLM is not None:
-            llm_tokenizer = AutoTokenizer.from_pretrained(LLM_MODEL_PATH, cache_dir=HF_CACHE_DIR)
-            llm_model = AutoModelForCausalLM.from_pretrained(LLM_MODEL_PATH, cache_dir=HF_CACHE_DIR)
+        # Use google/gemma-2b as the default local LLM (fast, small, chat-friendly)
+        if AutoTokenizer is not None and AutoModelForCausalLM is not None:
+            llm_tokenizer = AutoTokenizer.from_pretrained(LLM_MODEL_PATH, cache_dir="/tmp")
+            llm_model = AutoModelForCausalLM.from_pretrained(LLM_MODEL_PATH, cache_dir="/tmp")
             model_progress["llm"]["status"] = "ready"
             model_progress["llm"]["progress"] = 100.0
             logger.info(f"[JusticeAI] Loaded local LLM for background learning: {LLM_MODEL_PATH}")
@@ -588,11 +542,8 @@ async def startup_event():
         llm_tokenizer, llm_model = None, None
         model_progress["llm"]["status"] = "error"
         logger.warning(f"[JusticeAI] Could not load local LLM: {e}")
-
     startup_time = round(time.time() - t0, 2)
     logger.info(f"[JusticeAI] Startup completed in {startup_time}s")
-
-    # Heartbeat loop
     def heartbeat_loop():
         while True:
             last_heartbeat["time"] = datetime.utcnow().replace(tzinfo=timezone.utc).isoformat()
@@ -603,17 +554,12 @@ async def startup_event():
                 last_heartbeat["ok"] = False
             time.sleep(30)
     threading.Thread(target=heartbeat_loop, daemon=True).start()
-
-    # Background learning loop (every minute)
     def background_learning_loop():
         while True:
             try:
-                # Collect recent user interactions for learning
                 with engine.begin() as conn:
                     mem_rows = conn.execute(sql_text("SELECT text, reply, topic, confidence FROM user_memory ORDER BY created_at DESC LIMIT 200")).fetchall()
                     knowledge_rows = conn.execute(sql_text("SELECT text, reply, topic FROM knowledge WHERE category='learned' ORDER BY created_at DESC LIMIT 200")).fetchall()
-
-                # Use LLM for suggestions on each memory (if available)
                 if llm_model and llm_tokenizer and mem_rows:
                     for mem in mem_rows:
                         user_text = mem[0] or ""
@@ -634,10 +580,9 @@ async def startup_event():
             except Exception as e:
                 logger.warning(f"[Background AGI] Learning loop error: {e}")
             time.sleep(60)
-
     threading.Thread(target=background_learning_loop, daemon=True).start()
 
-# ----- Endpoints -----
+# ===== ENDPOINTS =====
 @app.get("/model-status")
 async def model_status():
     response_progress = {k: dict(v) for k, v in model_progress.items()}
@@ -847,7 +792,7 @@ async def chat(request: Request, data: dict = Body(...)):
     reply_lang = detected_lang
     user_force_save = bool(data.get("save_memory", False))
 
-    # Optional spell correction
+    # Spell correction
     if spell is not None:
         try:
             words = raw_msg.split()
@@ -861,19 +806,13 @@ async def chat(request: Request, data: dict = Body(...)):
     else:
         msg_corrected = raw_msg
 
-    # Simple intent classifier
     def classify_intent_local(text: str) -> str:
         t = text.lower()
-        if any(k in t for k in ["why", "para qué", "por qué"]):
-            return "why"
-        if any(k in t for k in ["solution", "solve", "how to", "how", "solución", "soluciona"]):
-            return "solution"
-        if any(k in t for k in ["disadvantage", "problem", "con ", "consecuencia", "desventaja", "issue"]):
-            return "disadvantage"
-        if any(k in t for k in ["benefit", "ventaja", "advantage", "pros"]):
-            return "advantage"
+        if any(k in t for k in ["why", "para qué", "por qué"]): return "why"
+        if any(k in t for k in ["solution", "solve", "how to", "how", "solución", "soluciona"]): return "solution"
+        if any(k in t for k in ["disadvantage", "problem", "con ", "consecuencia", "desventaja", "issue"]): return "disadvantage"
+        if any(k in t for k in ["benefit", "ventaja", "advantage", "pros"]): return "advantage"
         return "default"
-
     intent = classify_intent_local(raw_msg)
 
     # Infer topic if not provided
@@ -888,7 +827,7 @@ async def chat(request: Request, data: dict = Body(...)):
     else:
         topic = topic_hint
 
-    # Load only refined knowledge
+    # Load refined knowledge only
     try:
         with engine.begin() as conn:
             rows = conn.execute(sql_text("SELECT id, text, reply, language, embedding, topic FROM knowledge WHERE category='learned' ORDER BY created_at DESC")).fetchall()
@@ -901,7 +840,7 @@ async def chat(request: Request, data: dict = Body(...)):
     knowledge_langs = [r[3] or "en" for r in rows]
     knowledge_topics = [r[5] or "general" for r in rows]
 
-    # Translate the user message to English if needed
+    # Translate user message to English if needed
     en_msg = msg_corrected
     if detected_lang and detected_lang.split("-")[0].lower() not in ("en", "eng"):
         en_msg = translate_to_english(msg_corrected, detected_lang)
@@ -923,22 +862,16 @@ async def chat(request: Request, data: dict = Body(...)):
                 s = float(scores[i])
                 candidate = knowledge_replies[i]
                 candidate_lang = detect_language_safe(candidate)
-                if candidate_lang != "en":
-                    candidate_en = translate_to_english(candidate, candidate_lang)
-                else:
-                    candidate_en = candidate
+                candidate_en = translate_to_english(candidate, candidate_lang) if candidate_lang != "en" else candidate
                 key = candidate_en.strip().lower()
-                if is_boilerplate_candidate(candidate_en):
-                    continue
-                if key in seen_text:
-                    continue
+                if is_boilerplate_candidate(candidate_en): continue
+                if key in seen_text: continue
                 seen_text.add(key)
                 if s > 0.35:
                     filtered.append((i, s, candidate_en))
             matches = [c for _, _, c in filtered]
             confidence = filtered[0][1] if filtered else 0.0
         else:
-            # fallback simple substring matching
             for idx, ktext in enumerate(knowledge_texts):
                 ktext_lang = detect_language_safe(ktext)
                 ktext_en = translate_to_english(ktext, ktext_lang) if ktext_lang != "en" else ktext
@@ -951,7 +884,7 @@ async def chat(request: Request, data: dict = Body(...)):
         matches = knowledge_replies[:3] if knowledge_replies else []
         confidence = 0.0
 
-    # Send query to local LLM for inspiration (not direct reply)
+    # Local LLM inspiration (google/gemma-2b)
     llm_suggestion = ""
     try:
         if llm_model and llm_tokenizer:
@@ -965,19 +898,20 @@ async def chat(request: Request, data: dict = Body(...)):
         logger.debug(f"LLM suggestion error: {e}")
         llm_suggestion = ""
 
-    # Compose final reply using JusticeAI's internal synthesis logic, always in English
-    steps = []
     reply_en = synthesize_final_reply(en_msg, matches, llm_suggestion, intent)
     reply_en = dedupe_sentences(reply_en)
 
     # Translate to user's language if needed
     if reply_lang and reply_lang.split("-")[0].lower() not in ("en", "eng", "und"):
-        reply_final = translate_from_english(reply_en, reply_lang)
-        reply_final = dedupe_sentences(reply_final)
+        try:
+            reply_final = translate_from_english(reply_en, reply_lang)
+            reply_final = dedupe_sentences(reply_final)
+        except Exception as e:
+            logger.warning(f"Translation failure: {e}")
+            reply_final = reply_en
     else:
         reply_final = reply_en
 
-    # Mood & emoji
     mood = detect_mood(raw_msg + " " + reply_final)
     emoji = ""
     try:
@@ -993,7 +927,6 @@ async def chat(request: Request, data: dict = Body(...)):
     except Exception:
         emoji = ""
 
-    # Moderation (prevent toxic content from being saved)
     flags = {}
     try:
         if moderator is not None:
@@ -1006,7 +939,6 @@ async def chat(request: Request, data: dict = Body(...)):
     except Exception:
         pass
 
-    # Persist user memory if meaningful and not toxic
     try:
         should_save = user_force_save or (confidence >= SAVE_MEMORY_CONFIDENCE and not flags.get('toxic', False))
         if should_save:
@@ -1028,7 +960,6 @@ async def chat(request: Request, data: dict = Body(...)):
                         "topic": topic,
                     }
                 )
-                # Keep recent / high-confidence per topic
                 conn.execute(
                     sql_text("""
                     DELETE FROM user_memory
@@ -1045,15 +976,8 @@ async def chat(request: Request, data: dict = Body(...)):
     except Exception as e:
         logger.warning(f"user_memory persist error: {e}")
 
-    # OPTIONAL: include steps for debugging only if requested (default: False)
-    include_steps = bool(data.get("include_steps", False))
-    if include_steps and steps:
-        reasoning_text = " | ".join(str(s) for s in steps)
-        reply_final = f"{reply_final}\n\n[Reasoning steps: {reasoning_text}]"
-
     duration = time.time() - t0
     record_request(duration)
-
     return {
         "reply": reply_final,
         "topic": topic,